izolate / millify Goto Github PK

View Code? Open in Web Editor NEW

177.0 2.0 13.0 1012 KB

Convert long numbers to pretty, human-readable strings

Home Page: https://npmjs.com/package/millify

License: MIT License

TypeScript 53.86% JavaScript 46.14%

javascript units pretty human-readable human-readable-units abbreviations

millify's Introduction

Millify

Converts long numbers into pretty, human-readable strings.

Before 😒	After 🎉
`2000`	`'2K'`
`10000`	`'10k'`
`42500`	`'42.5 kg'`
`1250000`	`'1.25 MB'`
`2700000000`	`'2.7 bil'`

Install

Get it on npm:

npm install millify

Usage

Command line

$ millify 12345
12.3K

See millify --help for options.

Programmatically

`millify(value: number, options: MillifyOptions)`

import millify from "millify";

// For CommonJS: `const { millify } = require("millify");`

millify(2500); // 2.5K

millify(1024000, {
  precision: 3,
  lowercase: true
});
// 1.024m

millify(39500, {
  precision: 2,  
  locales: "de-DE"
});
// 3,95K

millify(1440000, {
  units: ["B", "KB", "MB", "GB", "TB"],
  space: true,
});
// 1.44 MB

Options

Name	Type	Default	Description
`precision`	`number`	`1`	Number of decimal places to use
`locales`	`string \| Array<string>`	browser language	Formats the number in different languages
`lowercase`	`boolean`	`false`	Use lowercase abbreviations
`space`	`boolean`	`false`	Add a space between number and abbreviation
`units`	`Array<string>`	`['', 'K', 'M', 'B', 'T', 'P', 'E']`	Unit abbreviations

millify's People

Contributors

Stargazers

Watchers

Forkers

kikobeats workaja amio dbankier 8bu xingyeqishi victkarangwa amit08255 ndinhbang hpohlmeyer sebasquirogaucp vyachee

millify's Issues

Handle big number

Consider to use BN.js or bignumber.js to handle big number?

I would like to specify a maximum number of significant digits for a number, so that I may better estimate how much space to allocate in design. Currently I may only specify precision and control decimals.

Currently:

millify(123456, {precision: 2}) returns 123.45K

Proposed:

millify(123456, {digits: 3}) returns 123K
millify(1234, {digits: 3}) returns 1.23K.

I'm willing to work on a patch if this is in scope for millify.

RFE: Should support strict precision

The precision argument isn't always honored if the resulting string ends in zeroes. There should be some kind of "padding" or "strict precision" argument so that the number is padded with trailing zeroes in the result. This would allow for right-aligned text (e.g. in tables) to always line up correctly.

Any plans to support BigInts?

Hi there!
I noticed we throw an error whenever we're out of the range of Number.MAX_SAFE_INTEGER and Number.MIN_SAFE_INTEGER. Are there any plans to support BigInt so we can exceed this range sometime in the future?
Cheers

require('millify') is no longer a function

See: https://runkit.com/embed/9quxu0kjbiak

The basic case now requires a 'default' property to access the main functionality:

const millify = require("millify");
millify.default(10000);

It seems this is an oversight? Bringing to your attention. Thanks!

`millify` does not check for `undefined` or `null` values

When first calling millify the package passes the value to parseValue. On the first line there it calls value.toString() without first checking if value actually exists:

millify/lib/utils.ts

Lines 4 to 14 in 8cc295d

    
           export function parseValue(value: number): number { 
        
             const val: number = parseFloat(value.toString()); 
        
             if (isNaN(val)) { 
        
               throw new Error(`Input value is not a number`); 
        
             } 
        
             if (val > Number.MAX_SAFE_INTEGER || val < Number.MIN_SAFE_INTEGER) { 
        
               throw new RangeError("Input value is outside of safe integer range"); 
        
             } 
        
             return val; 
        
           }

// Change this
const val: number = parseFloat(value.toString());

// To this
const val: number = parseFloat(value?.toString());

See this StackOverflow post for an example of how this can be problematic

millify is not a function

I'm using this in a discord bot.
My code is below

const millify = require("millify");

    const views = millify(npsong.views);
    const like = millify(npsong.likes);
    const lislikes = millify(npsong.dislikes);

I'm getting the error millify is not a function

Number rounds up erroneously

https://codesandbox.io/s/magical-water-f7f84n?file=/src/index.js:0-164

import millify from "millify";

const OneBelow1Mill = 999999;
const OneBelow100G = 99999;

console.log(millify(OneBelow1Mill));
console.log(millify(OneBelow100G));

Output:

1M
100K

It should be:

999K
99K

Should it not? Why is it rounding up?

Types don't match code when this library is used in ESM

This library is CJS, so when used from an ESM module, you have to do this:

import millify from 'millify';

millify.default(...)

However, this doesn't match up with the published types, which expect the default export to be used directly.

Changelog for version 3

Is there any breaking change in the release?

Decimal parameter doesn't work as expected

Fix it.

Unexpected token operator when doing a build using create-react-app

npm run build generates the following error:

static/js/main.31e960bf.js from UglifyJs
SyntaxError: Unexpected token: operator (>) [./~/millify/index.js:7,0]

npm ls millify
...
└── [email protected]

	export function parseValue(value: number): number {
	const val: number = parseFloat(value.toString());

	if (isNaN(val)) {
	throw new Error(`Input value is not a number`);
	}
	if (val > Number.MAX_SAFE_INTEGER \|\| val < Number.MIN_SAFE_INTEGER) {
	throw new RangeError("Input value is outside of safe integer range");
	}
	return val;
	}