coddyger
Version:
Coddyger est une bibliothèque JavaScript/TypeScript qui fournit des fonctions communes et des plugins pour la gestion des données, la communication entre services, et des utilitaires avancés pour le développement d'applications.
551 lines (550 loc) • 21.5 kB
TypeScript
import { CountryCode } from 'libphonenumber-js';
declare const coddyger: {
/**
* Gère les réponses API de manière standardisée
* @param context - Le contexte de la requête HTTP
* @param promise - La promesse à traiter
*/
api: (context: any, promise: Promise<any>) => void;
/**
* Affiche des messages de log formatés avec horodatage et niveau de log
* @param msg - Le message à logger
* @param error - 1 pour erreur, 0 pour info
*/
konsole: (msg: any, error?: number) => void;
string: {
/**
* Vérifie si une valeur est vide
* @param value - La valeur à vérifier
* @returns true si la valeur est vide, null ou undefined
*/
isEmpty: (value: any) => boolean;
/**
* Vérifie si une chaîne est une adresse email valide
* @param payload - L'email à vérifier
* @returns true si l'email est valide
*/
isEmailAddress: (payload: string) => boolean;
/**
* Vérifie si une chaîne est un nombre valide
* @param payload - La chaîne à vérifier
* @returns true si la chaîne est un nombre
*/
isNumber: (payload: string) => boolean;
/**
* Vérifie si une chaîne est une date valide
* @param payload - La chaîne à vérifier
* @returns true si la chaîne est une date valide
*/
isDate: (payload: string) => boolean;
/**
* Vérifie si une chaîne est un ObjectId MongoDB valide
* @param payload - La chaîne à vérifier
* @returns true si la chaîne est un ObjectId valide
*/
isValidObjectId: (payload: string) => boolean;
/**
* Génère un nouvel ObjectId MongoDB
* @returns Un nouvel ObjectId
*/
generateObjectId: () => any;
/**
* Convertit une chaîne en ObjectId MongoDB
* @param value - La valeur à convertir
* @returns L'ObjectId correspondant
*/
toObjectId: (value: any) => any;
/**
* Chiffre un mot de passe
* @param payload - Le mot de passe à chiffrer
* @returns Le mot de passe chiffré
*/
encryptPassword: (payload: string) => Promise<string>;
/**
* Vérifie un mot de passe par rapport à sa version chiffrée
* @param payload - Le mot de passe en clair
* @param hashedPayload - Le mot de passe chiffré
* @returns true si les mots de passe correspondent
*/
decryptPassword: (payload: string, hashedPayload: string) => Promise<boolean>;
/**
* Met en majuscule la première lettre de chaque mot
* @param payload - Le texte à transformer
* @returns Le texte avec les premières lettres en majuscule
*/
capitalizeEachWord: (payload: string) => string;
/**
* Convertit un texte en vecteur numérique (vectorisation)
* @param text - Le texte à vectoriser
* @returns Un vecteur de fréquences des mots
*/
vectorizeText: (text: string) => number[];
/**
* Calcule la similarité cosinus entre deux vecteurs
* @param vector1 - Premier vecteur
* @param vector2 - Second vecteur
* @returns La similarité cosinus entre les deux vecteurs (entre 0 et 1)
*/
cosineSimilarity: (vector1: number[], vector2: number[]) => number;
/**
* Vérifie si une chaîne est un numéro de téléphone valide
* @param phoneNumber - Le numéro de téléphone à vérifier
* @param countryCode - Le code pays optionnel (ex: 'FR', 'US')
* @returns true si le numéro est valide
*/
isValidPhoneNumber: (phoneNumber: string, countryCode?: CountryCode) => boolean;
/**
* Obtient le code pays à partir d'un préfixe téléphonique
* @param prefix - Le préfixe téléphonique (ex: +33, +1)
* @returns Le code pays correspondant ou null si non trouvé
*/
getCountryCodeFromPrefix: (prefix: string) => string | null;
/**
* Obtient la liste des pays avec leurs codes, noms et drapeaux
* @returns Un tableau d'objets pays
*/
getCountryList: () => Array<{
code: string;
name: string;
flag: string;
phoneCode: string;
}>;
/**
* Génère un mot de passe aléatoire sécurisé
* @param length - Longueur du mot de passe (défaut: 12)
* @param includeSymbols - Inclure des symboles spéciaux (défaut: true)
* @returns Un mot de passe aléatoire sécurisé
*/
generateSecurePassword: (length?: number, includeSymbols?: boolean) => string;
/**
* Génère un code PIN numérique aléatoire
* @param length - Longueur du code PIN (défaut: 6)
* @returns Un code PIN numérique
*/
generatePIN: (length?: number) => string;
/**
* Génère un token aléatoire alphanumérique
* @param length - Longueur du token (défaut: 32)
* @returns Un token aléatoire
*/
generateToken: (length?: number) => string;
/**
* Nettoie et normalise une chaîne de caractères
* @param text - Le texte à nettoyer
* @returns Le texte nettoyé
*/
cleanText: (text: string) => string;
/**
* Tronque un texte à une longueur spécifiée avec des points de suspension
* @param text - Le texte à tronquer
* @param maxLength - Longueur maximale (défaut: 100)
* @param suffix - Suffixe à ajouter (défaut: "...")
* @returns Le texte tronqué
*/
truncate: (text: string, maxLength?: number, suffix?: string) => string;
/**
* Convertit un texte en slug URL-friendly
* @param text - Le texte à convertir
* @returns Le slug généré
*/
slugify: (text: string) => string;
/**
* Masque partiellement une chaîne (utile pour emails, téléphones)
* @param text - Le texte à masquer
* @param visibleStart - Nombre de caractères visibles au début (défaut: 2)
* @param visibleEnd - Nombre de caractères visibles à la fin (défaut: 2)
* @param maskChar - Caractère de masquage (défaut: "*")
* @returns Le texte masqué
*/
maskString: (text: string, visibleStart?: number, visibleEnd?: number, maskChar?: string) => string;
};
array: {
/**
* Compare deux tableaux pour vérifier s'ils sont identiques
* @param array1 - Premier tableau
* @param array2 - Second tableau
* @returns true si les tableaux sont identiques
*/
compare: (array1: Array<any>, array2: Array<any>) => boolean;
/**
* Vérifie si une valeur existe dans un tableau
* @param needle - La valeur à rechercher
* @param haystack - Le tableau dans lequel chercher
* @returns true si la valeur est trouvée
*/
inArray: (needle: any, haystack: any) => boolean;
/**
* Supprime les doublons d'un tableau
* @param array - Le tableau à dédupliquer
* @returns Un nouveau tableau sans doublons
*/
unique: (array: Array<any>) => Array<any>;
/**
* Mélange aléatoirement les éléments d'un tableau
* @param array - Le tableau à mélanger
* @returns Un nouveau tableau mélangé
*/
shuffle: (array: Array<any>) => Array<any>;
/**
* Divise un tableau en chunks de taille spécifiée
* @param array - Le tableau à diviser
* @param size - Taille de chaque chunk
* @returns Un tableau de chunks
*/
chunk: (array: Array<any>, size: number) => Array<Array<any>>;
/**
* Trouve l'intersection de deux tableaux
* @param array1 - Premier tableau
* @param array2 - Second tableau
* @returns Les éléments communs aux deux tableaux
*/
intersection: (array1: Array<any>, array2: Array<any>) => Array<any>;
/**
* Trouve la différence entre deux tableaux
* @param array1 - Premier tableau
* @param array2 - Second tableau
* @returns Les éléments du premier tableau qui ne sont pas dans le second
*/
difference: (array1: Array<any>, array2: Array<any>) => Array<any>;
};
object: {
/**
* Clone profondément un objet
* @param obj - L'objet à cloner
* @returns Une copie profonde de l'objet
*/
deepClone: (obj: any) => any;
/**
* Fusionne deux objets profondément
* @param target - L'objet cible
* @param source - L'objet source
* @returns L'objet fusionné
*/
deepMerge: (target: any, source: any) => any;
/**
* Obtient une valeur dans un objet par un chemin de propriétés
* @param obj - L'objet source
* @param path - Le chemin vers la propriété (ex: "user.profile.name")
* @param defaultValue - Valeur par défaut si la propriété n'existe pas
* @returns La valeur trouvée ou la valeur par défaut
*/
get: (obj: any, path: string, defaultValue?: any) => any;
/**
* Définit une valeur dans un objet par un chemin de propriétés
* @param obj - L'objet cible
* @param path - Le chemin vers la propriété (ex: "user.profile.name")
* @param value - La valeur à définir
* @returns L'objet modifié
*/
set: (obj: any, path: string, value: any) => any;
/**
* Supprime les propriétés avec des valeurs nulles ou undefined
* @param obj - L'objet à nettoyer
* @returns L'objet nettoyé
*/
removeNullish: (obj: any) => any;
};
number: {
/**
* Formate un nombre avec des séparateurs de milliers
* @param num - Le nombre à formater
* @param locale - La locale à utiliser (défaut: 'fr-FR')
* @returns Le nombre formaté
*/
format: (num: number, locale?: string) => string;
/**
* Formate un nombre en devise
* @param num - Le nombre à formater
* @param currency - La devise (défaut: 'EUR')
* @param locale - La locale à utiliser (défaut: 'fr-FR')
* @returns Le nombre formaté en devise
*/
formatCurrency: (num: number, currency?: string, locale?: string) => string;
/**
* Génère un nombre aléatoire entre min et max (inclus)
* @param min - Valeur minimale
* @param max - Valeur maximale
* @returns Un nombre aléatoire
*/
random: (min: number, max: number) => number;
/**
* Arrondit un nombre à un nombre spécifié de décimales
* @param num - Le nombre à arrondir
* @param decimals - Nombre de décimales (défaut: 2)
* @returns Le nombre arrondi
*/
round: (num: number, decimals?: number) => number;
/**
* Convertit des octets en format lisible (KB, MB, GB, etc.)
* @param bytes - Nombre d'octets
* @param decimals - Nombre de décimales (défaut: 2)
* @returns La taille formatée
*/
formatBytes: (bytes: number, decimals?: number) => string;
/**
* Calcule le pourcentage d'une valeur par rapport à un total
* @param value - La valeur
* @param total - Le total
* @param decimals - Nombre de décimales (défaut: 2)
* @returns Le pourcentage
*/
percentage: (value: number, total: number, decimals?: number) => number;
};
url: {
/**
* Vérifie si une chaîne est une URL valide
* @param url - L'URL à vérifier
* @returns true si l'URL est valide
*/
isValid: (url: string) => boolean;
/**
* Extrait le domaine d'une URL
* @param url - L'URL source
* @returns Le domaine ou null si invalide
*/
getDomain: (url: string) => string | null;
/**
* Construit une URL avec des paramètres de requête
* @param baseUrl - L'URL de base
* @param params - Les paramètres à ajouter
* @returns L'URL complète avec paramètres
*/
buildWithParams: (baseUrl: string, params: Record<string, any>) => string;
/**
* Parse les paramètres de requête d'une URL
* @param url - L'URL à parser
* @returns Un objet avec les paramètres
*/
parseParams: (url: string) => Record<string, string>;
};
validation: {
/**
* Vérifie si une valeur est un JSON valide
* @param str - La chaîne à vérifier
* @returns true si c'est un JSON valide
*/
isValidJSON: (str: string) => boolean;
/**
* Vérifie la force d'un mot de passe
* @param password - Le mot de passe à vérifier
* @returns Un objet avec le score et les détails
*/
passwordStrength: (password: string) => {
score: number;
strength: string;
feedback: string[];
};
/**
* Vérifie si une chaîne contient uniquement des caractères alphanumériques
* @param str - La chaîne à vérifier
* @returns true si alphanumérique uniquement
*/
isAlphanumeric: (str: string) => boolean;
/**
* Vérifie si une chaîne est un code postal français valide
* @param postalCode - Le code postal à vérifier
* @returns true si valide
*/
isFrenchPostalCode: (postalCode: string) => boolean;
/**
* Vérifie si une chaîne est un numéro SIRET français valide
* @param siret - Le numéro SIRET à vérifier
* @returns true si valide
*/
isSIRET: (siret: string) => boolean;
/**
* Vérifie si une chaîne est un IBAN valide
* @param iban - L'IBAN à vérifier
* @returns true si valide
*/
isIBAN: (iban: string) => boolean;
};
/**
* Construit un objet d'erreur API standardisé
* @param payload - Les données d'erreur
* @returns L'objet d'erreur formaté
*/
buildApiError: (payload: any) => {
errors: {
value: any;
msg: any;
param: any;
location: any;
};
};
/**
* Obtient la date courante ou la formate
* @param type - 'string' pour format chaîne, sinon objet Date
* @returns La date formatée
*/
getDate: (type?: string) => string | Date;
file: {
/**
* Supprime un fichier
* @param filePath - Chemin du fichier à supprimer
*/
remove: (filePath: string) => void;
/**
* Récupère l'extension d'un fichier
* @param filename - Nom du fichier
* @returns L'extension en minuscules
*/
extension: (filename: string) => string;
/**
* Convertit un fichier en Base64
* @param filename - Nom du fichier
* @returns Le contenu du fichier en Base64
*/
toBase64: (filename: string) => string;
/**
* Vérifie si un fichier existe
* @param filePath - Chemin du fichier
* @returns true si le fichier existe
*/
exists: (filePath: string) => boolean;
/**
* Télécharge un fichier depuis une URL
* @param url - URL du fichier
* @param filename - Nom du fichier de destination
* @returns Une promesse résolue quand le téléchargement est terminé
*/
download: (url: string, filename: string) => Promise<unknown>;
};
/**
* Calcule le nombre de jours entre une date et aujourd'hui
* @param startDate - Date de début
* @returns Nombre de jours écoulés
*/
calculateDaysBetween(startDate: Date): number;
/**
* Génère un slug unique avec préfixe et date
* @param prefix - Préfixe du slug
* @param lastReference - Dernière référence utilisée
* @returns Le nouveau slug généré
*/
buildSlug(prefix: string, lastReference?: string | null): string;
/**
* Obtient le nombre de jours dans un mois donné
* @param month - Numéro du mois (1-12)
* @param year - Année
* @returns Nombre de jours dans le mois
*/
getDaysInMonth: (month: number, year: number) => any;
/**
* Obtient les semaines d'un mois donné
* @param month - Numéro du mois (1-12)
* @param year - Année
* @returns Tableau des semaines avec leurs dates de début et fin
*/
getWeeksInMonth: (month: number, year: number) => any[];
/**
* Formate une date en format YYYY-MM-DD
* @param date - La date à formater
* @returns La date formatée en chaîne YYYY-MM-DD
*/
dateOnlyFormat: (date: Date | string) => string;
dates: {
/**
* Formate une date selon un format spécifique
* @param date - La date à formater
* @param formatStr - Le format désiré (ex: 'dd/MM/yyyy')
* @param locale - La locale à utiliser (par défaut: fr)
* @returns La date formatée selon le format spécifié
*/
format: (date: Date | string, formatStr?: string, locale?: import("date-fns").Locale) => string;
/**
* Vérifie si une date est valide
* @param date - La date à vérifier
* @returns true si la date est valide
*/
isValid: (date: Date | string) => boolean;
/**
* Ajoute un nombre de jours à une date
* @param date - La date de départ
* @param days - Nombre de jours à ajouter
* @returns La nouvelle date
*/
addDays: (date: Date | string, days: number) => Date;
/**
* Soustrait un nombre de jours d'une date
* @param date - La date de départ
* @param days - Nombre de jours à soustraire
* @returns La nouvelle date
*/
subDays: (date: Date | string, days: number) => Date;
/**
* Calcule la différence en jours entre deux dates
* @param dateLeft - Première date
* @param dateRight - Deuxième date
* @returns Nombre de jours de différence
*/
diffInDays: (dateLeft: Date | string, dateRight: Date | string) => number;
/**
* Obtient le début de la semaine pour une date donnée
* @param date - La date
* @returns Date du début de la semaine
*/
startOfWeek: (date: Date | string) => Date;
/**
* Obtient la fin de la semaine pour une date donnée
* @param date - La date
* @returns Date de fin de la semaine
*/
endOfWeek: (date: Date | string) => Date;
/**
* Obtient le début du mois pour une date donnée
* @param date - La date
* @returns Date du début du mois
*/
startOfMonth: (date: Date | string) => Date;
/**
* Obtient la fin du mois pour une date donnée
* @param date - La date
* @returns Date de fin du mois
*/
endOfMonth: (date: Date | string) => Date;
/**
* Vérifie si une date est dans un intervalle
* @param date - La date à vérifier
* @param startDate - Date de début de l'intervalle
* @param endDate - Date de fin de l'intervalle
* @returns true si la date est dans l'intervalle
*/
isWithinInterval: (date: Date | string, startDate: Date | string, endDate: Date | string) => boolean;
/**
* Obtient le nombre de jours dans un mois donné
* @param month - Numéro du mois (1-12)
* @param year - Année
* @returns Nombre de jours dans le mois
*/
getDaysInMonthCount: (month: number, year: number) => number;
};
/**
* Retourne le chemin absolu du répertoire racine de l'application
* @returns Le chemin absolu de la racine du projet
*/
root: () => string;
/**
* Inclut rcursivement les fichiers d'un répertoire selon une extension
* @param dir - Le répertoire à scanner
* @param payload - L'extension des fichiers à inclure (sans le point)
* @returns Un tableau des classes exportées depuis les fichiers
*/
filesInclude(dir: any, payload: string): any[];
/**
* Gère les retours d'erreur de manière standardisée
* @param e - L'erreur à traiter
* @param location - L'emplacement où l'erreur s'est produite
* @param method - La méthode où l'erreur s'est produite
* @returns Un objet d'erreur formaté
*/
catchReturn(e: any, location: string, method: string): {
status: number;
message: string;
} | {
status: number;
message: string;
data: any;
};
};
export default coddyger;