Latest
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434import DateTime from "./DateTimeHumanity.ts";import { en_US, ru_RU, de_DE, LocaleObject } from "./Locales.ts";
export type Feature = "spacing";export type LocaleHumanity = "ru_RU" | "en_US" | "de_DE" | "custom";
class Humanity { private localeObject: LocaleObject; private withSpace = true; private suffixes = ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
public dateTime = DateTime;
/** * Constructor for setting locale * @param locale Locale to be used */ constructor(locale: LocaleHumanity = "en_US", customLocale?: LocaleObject) { if (locale == "custom" && customLocale) { this.localeObject = customLocale; } else { this.localeObject = this.getLocale(locale); } type KeysOfUnion<T> = T extends T ? keyof T : string;
/** * MAP OF SUFFIXES */ const mapSuffixes = { Bytes: 0, KiloBytes: 1, MegaBytes: 2, GigaBytes: 3, TeraBytes: 4, PetaBytes: 5, ExaBytes: 6, ZettaBytes: 7, YottaBytes: 8, };
// Replace suffixes on custom suffixes if (this.localeObject.binarySuffixes) { Object.entries(this.localeObject.binarySuffixes).forEach( (value) => { const key = value[0]; const valueOfKey = value[1]; // @ts-ignore - typescript doesn't know about this this.suffixes[mapSuffixes[key]] = valueOfKey; } ); } }
/** * Disable functionality of features * ```typescript * // This feature disable space between number and word * const Humanity = createHumanity(); * Humanity.disableFeature("spacing"); * console.log(Humanity.number(100000)); * // Output: 100thousand * ``` * @param feature Feature to be used */ disableFeature(feature: Feature) { switch (feature) { case "spacing": this.withSpace = false; break; } }
getLocale(locale: LocaleHumanity): LocaleObject { switch (locale) { case "ru_RU": return ru_RU; case "en_US": return en_US; case "de_DE": return de_DE; default: return en_US; } }
private declinationNumbers( n: number | bigint, lenZeros: number ): "plural" | "singular" | "pluar_singular" { if ( this.localeObject.useCountZerosAfterFirstDigit == true && lenZeros % 3 > 0 && lenZeros > 5 ) { return "plural"; }
if (n == 1) { return "singular"; } if (n > 1 && n < 5) { return "pluar_singular"; }
return "plural"; }
/** * @param lenZeros Length of the number * @returns string */ private getZerosByCountZeros(lenZeros: number): string { return lenZeros % 3 == 0 ? "" : new Array(lenZeros % 3).fill("0").join(""); }
private switchWord(lenZeros: number): string { const numbers = Object.keys(this.localeObject.numbers); if (lenZeros < 5 || lenZeros > (numbers.length + 1) * 3) { return lenZeros.toString(); }
const found = Math.floor(lenZeros / 3) - 1; if ( this.localeObject.excludeNumbers && this.localeObject.excludeNumbers.some((x) => x == numbers[found]) ) { return lenZeros.toString(); }
return Object.values(this.localeObject.numbers)[found]; }
/** * Max returned number quintillion * ```typescript * Humanity.number(100); // return a humanized number * ``` * @param n Number to be converted to a string * @returns string representation of the number */ number(n: number | bigint): string { let number = Array.from(n.toString()); if (number.indexOf(".") != -1) { number = number.splice(number.indexOf(".")); } const lenZeros = number.length - 1; const firstDigit = typeof n == "bigint" ? BigInt(number[0]) : Number(number[0]);
const declination = this.declinationNumbers(firstDigit, lenZeros);
const zeros = this.getZerosByCountZeros(lenZeros); const numberStr = firstDigit + zeros; const nameOfNumber = this.switchWord(lenZeros);
if (nameOfNumber == lenZeros.toString()) { return n.toString(); }
if (this.localeObject.declinations) { return `${numberStr}${this.spaceIf()}${nameOfNumber}${ this.localeObject.declinations[declination] }`; } else { return `${numberStr}${this.spaceIf()}${nameOfNumber}`; } }
private spaceIf() { return this.withSpace ? " " : ""; }
/** * Truncate string to max length and paste in end '...' * ```typescript * const str = Humanity.truncate( * "Humanity is a library for humanizing data in a human-readable form.", * 24 * ); * * console.log(str); * * // Output: Humanity is a library fo... * ``` * @param n Number to be converted to a string * @param lengthMax * @returns string */ truncate(n: string | number | bigint, lengthMax: number): string { if (typeof n == "number") { n = n.toString(); } if (typeof n == "bigint") { n = n.toString(); } if (n.length > lengthMax) { return n.substring(0, lengthMax) + "..."; } return n; }
/** * Convert arabic number to roman numerals * @param n Number to be converted to a roman numerals * @returns string */ toRoman(n: number): string { const roman = { M: 1000, CM: 900, D: 500, CD: 400, C: 100, XC: 90, L: 50, XL: 40, X: 10, IX: 9, V: 5, IV: 4, I: 1, }; let romanNum = ""; for (const [key, value] of Object.entries(roman)) { while (n >= value) { romanNum += key; n -= value; } } return romanNum; }
/** * Convert bytes to human readable format * ### Example * 0 B * * 1.00 B * * 1.00 KB * * 1.00 KB * @param bytes Number of bytes * @param fixed Number of decimal places * @returns string */ binarySuffix(bytes: number, fixed = 2): string { if (bytes == 0) { return `0${this.spaceIf()}${this.suffixes[0]}`; }
const i = Math.floor(Math.log(bytes) / Math.log(1024)); return `${(bytes / Math.pow(1024, i)).toFixed(fixed)}${this.spaceIf()}${ this.suffixes[i] }`; }
/** * Collection data to string * ```typescript * const chatMembers = ["Dustin", "Leda", "Tristin", "Maybelle", "Dee", "Stephon"]; * const r = Humanity.arrayToText(chatMembers, 3); * console.log(r); * // Output: Dustin, Leda, Tristin and 3 others * ``` * @param arr Array with your content * @param n length to slice of array * @returns string */ arrayToText<T = string>(arr: T[], n = 2): string { const SEPARATOR = this.localeObject.separator + " ";
if (n == 0 || arr.length == 1) { return String(arr[0]); }
if (arr.length < n) { return arr.slice(0).join(SEPARATOR); }
if (arr.length > n) { return ( arr.slice(0, n).join(SEPARATOR) + " " + this.localeObject.words.and + " " + (arr.length - n) + " " + this.localeObject.words.others ); }
return arr.slice(0, n).join(SEPARATOR) + "..."; }
humanCase(data: string): string { const lengthOfString = data.length;
const wordsMap: number[] = [];
let isCamelCase = false; let isUpperCamelCase = false; let isSnakeCase = false;
if (lengthOfString <= 1) { return data; }
const firstLetter = data.charAt(0);
// Check first letter for future check for camelCase if (this.isUpperCase(firstLetter)) { isUpperCamelCase = true; } else { isCamelCase = true; }
// Check if string is a snake case if (data.includes("_")) { isSnakeCase = true; }
// Change state two variables if detecting that string is not camelCase isCamelCase = !isSnakeCase; isUpperCamelCase = !isSnakeCase;
// Foreach all string by char to char for (let i = 1; i < lengthOfString; i++) { const letter = data.charAt(i);
// Check if letter is upper case if (this.isUpperCase(letter) && (isUpperCamelCase || isCamelCase)) { addWordToMap(i); }
// Check if is underscore if (letter == "_") { addWordToMap(i); } }
let result: string[] = []; let i = 0;
wordsMap.forEach((word) => { result.push(data.slice(i, word)); i = word; });
result.push(data.slice(i));
result = result .map((word, i) => { if (isSnakeCase && i != 0) { return word.slice(1); }
if (i == 0) { return word.slice(0, 1).toUpperCase() + word.slice(1); }
return word.toLowerCase(); }) .filter((word) => word.length > 1); function addWordToMap(index: number) { wordsMap.push(index); }
return result.join(" "); }
/** * If char is uppercase * @param char * @returns boolean */ isUpperCase(char: string): boolean { return char.toUpperCase() === char; }
/** * If char is lowercase * @param char * @returns boolean */ isLowerCase(char: string): boolean { return char.toLowerCase() === char; }}
/** * create Humanity instance with default locale * ```typescript * const Humanity = createHumanity('en_US'); * console.log(Humanity.number(500000)); // 500 000 * // Output: 500 thousand * ``` * @param locale Locale to be used * @returns Humanity instance */function createHumanity(locale: LocaleHumanity = "en_US"): Humanity { return new Humanity(locale);}
/** * create Humanity instance with custom locale * ```typescript * const Humanity = createCustomHumanity({ * locale: "custom", * numbers: { * thousand: "tis", * million: "er", * billion: "pe", * trillion: "xe", * quadrillion: "fa", * quintillion: "ier", * }, * }); * * console.log(Humanity.number(1000000)); // 1 000 000 * // Output: 1 er * ``` * @param locale Locale to be used * @returns Humanity instance */function createCustomHumanity(locale: LocaleObject): Humanity { return new Humanity("custom", locale);}
export default new Humanity();export { createHumanity, createCustomHumanity };