@jsenv/humanize 1.0.0 → 1.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/humanize",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "Generate messages meant to read by humans",
   "license": "MIT",
   "repository": {
@@ -39,10 +39,10 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "string-width": "7.0.0"
+    "string-width": "7.2.0"
   },
   "devDependencies": {
-    "ansi-escapes": "6.2.0",
+    "ansi-escapes": "7.0.0",
     "is-unicode-supported": "2.0.0",
     "supports-color": "9.4.0"
   }

package/src/.jsenv/jsenv_tests_output.txt

@@ -1,35 +1,32 @@
------------ 23 executions to run ------------
-20 with node (node_worker_thread@20.11.0)
-1 with chromium (chromium@120.0.6099.28)
-1 with firefox (firefox@119.0)
-1 with webkit (webkit@17.4)
+-------------- execution start --------------
+21 files matching "testPlan" in /Users/damien.maillard/dev/perso/jsenv-core/packages/independent/humanize/src
 ---------------------------------------------
 
-✔ 01/23 _tests/byte/file_size.test.js [node/0.03s/1.2MB] (1 completed)
-✔ 02/23 _tests/byte/memory_usage.test.js [node/0.03s/1.2MB] (2 completed)
-✔ 03/23 _tests/content_frame/content_frame.test.js [node/0.1s/2.6MB] (3 completed)
-✔ 04/23 _tests/js_value/_inspect.test.html [chromium/0.2s/10.1MB] (4 completed)
-✔ 05/23 _tests/js_value/_inspect.test.html [firefox/0.2s] (5 completed)
-✔ 06/23 _tests/js_value/_inspect.test.html [webkit/0.3s] (6 completed)
-✔ 07/23 _tests/js_value/array.test.js [node/0.09s/1.2MB] (7 completed)
-✔ 08/23 _tests/js_value/biginit.test.js [node/0.06s/1.2MB] (8 completed)
-✔ 09/23 _tests/js_value/boolean.test.js [node/0.1s/1.2MB] (9 completed)
-✔ 10/23 _tests/js_value/date.test.js [node/0.04s/1.2MB] (10 completed)
-✔ 11/23 _tests/js_value/error.test.js [node/0.05s/1.2MB] (11 completed)
-✔ 12/23 _tests/js_value/function.test.js [node/0.05s/1.2MB] (12 completed)
-✔ 13/23 _tests/js_value/instance.test.js [node/0.05s/1.2MB] (13 completed)
-✔ 14/23 _tests/js_value/null.test.js [node/0.04s/1.2MB] (14 completed)
-✔ 15/23 _tests/js_value/number.test.js [node/0.06s/1.3MB] (15 completed)
-✔ 16/23 _tests/js_value/object.test.js [node/0.05s/1.3MB] (16 completed)
-✔ 17/23 _tests/js_value/regexp.test.js [node/0.05s/1.2MB] (17 completed)
-✔ 18/23 _tests/js_value/string.test.js [node/0.05s/1.2MB] (18 completed)
-✔ 19/23 _tests/js_value/symbol.test.js [node/0.05s/1.2MB] (19 completed)
-✔ 20/23 _tests/js_value/undefined.test.js [node/0.06s/1.2MB] (20 completed)
-✔ 21/23 _tests/time/decimals.test.js [node/0.03s/1.2MB] (21 completed)
-✔ 22/23 _tests/time/duration.test.js [node/0.03s/1.2MB] (22 completed)
-✔ 23/23 _tests/time/ellapsed.test.js [node/0.02s/1.2MB] (all completed)
+✔ 01/23 _tests/byte/file_size.test.js [node/0.03s] (1 completed)
+✔ 02/23 _tests/byte/memory.test.js [node/0.03s] (2 completed)
+✔ 03/23 _tests/content_frame/content_frame.test.js [node/0.07s] (3 completed)
+✔ 04/23 _tests/js_value/_inspect.test.html [chromium/0.2s] (4 completed)
+✔ 05/23 _tests/js_value/_inspect.test.html [firefox/0.1s] (5 completed)
+✔ 06/23 _tests/js_value/_inspect.test.html [webkit/0.2s] (6 completed)
+✔ 07/23 _tests/js_value/array.test.js [node/0.03s] (7 completed)
+✔ 08/23 _tests/js_value/biginit.test.js [node/0.03s] (8 completed)
+✔ 09/23 _tests/js_value/boolean.test.js [node/0.05s] (9 completed)
+✔ 10/23 _tests/js_value/date.test.js [node/0.03s] (10 completed)
+✔ 11/23 _tests/js_value/error.test.js [node/0.03s] (11 completed)
+✔ 12/23 _tests/js_value/function.test.js [node/0.04s] (12 completed)
+✔ 13/23 _tests/js_value/instance.test.js [node/0.03s] (13 completed)
+✔ 14/23 _tests/js_value/null.test.js [node/0.05s] (14 completed)
+✔ 15/23 _tests/js_value/number.test.js [node/0.06s] (15 completed)
+✔ 16/23 _tests/js_value/object.test.js [node/0.07s] (16 completed)
+✔ 17/23 _tests/js_value/regexp.test.js [node/0.05s] (17 completed)
+✔ 18/23 _tests/js_value/string.test.js [node/0.04s] (18 completed)
+✔ 19/23 _tests/js_value/symbol.test.js [node/0.03s] (19 completed)
+✔ 20/23 _tests/js_value/undefined.test.js [node/0.02s] (20 completed)
+✔ 21/23 _tests/time/decimals.test.js [node/0.02s] (21 completed)
+✔ 22/23 _tests/time/duration.test.js [node/0.03s] (22 completed)
+✔ 23/23 _tests/time/ellapsed.test.js [node/0.02s] (all completed)
 
------------------- summary ------------------
+--------------- execution end ---------------
 23 executions: all completed
-duration: 4.4s (setup: 0.4s, execution: 4.2s, teardown: 0.2s)
+duration: 2.4s (setup: 0.4s, execution: 2.3s, teardown: 0.2s)
 ---------------------------------------------

package/src/_tests/byte/file_size.test.js

@@ -2,9 +2,9 @@ import { assert } from "@jsenv/assert";
 
 import { humanizeFileSize } from "@jsenv/humanize";
 
-const test = (fileSize, expected) => {
+const test = (fileSize, expect) => {
   const actual = humanizeFileSize(fileSize);
-  assert({ actual, expected });
+  assert({ actual, expect });
 };
 
 test(0, "0 B");

package/src/_tests/byte/memory.test.js

@@ -0,0 +1,11 @@
+import { assert } from "@jsenv/assert";
+
+import { humanizeMemory } from "@jsenv/humanize";
+
+const test = (memoryUsageInBytes, expect) => {
+  const actual = humanizeMemory(memoryUsageInBytes);
+  assert({ actual, expect });
+};
+
+test(1000, "1.0 kB");
+test(1100, "1.1 kB");

package/src/_tests/js_value/array.test.js

@@ -3,35 +3,35 @@ import { humanize } from "@jsenv/humanize";
 
 {
   const actual = humanize([]);
-  const expected = `[]`;
-  assert({ actual, expected });
+  const expect = `[]`;
+  assert({ actual, expect });
 }
 
 {
   const actual = humanize([[]]);
-  const expected = `[
+  const expect = `[
   []
 ]`;
-  assert({ actual, expected });
+  assert({ actual, expect });
 }
 
 {
   const actual = humanize(Array(3));
   // prettier-ignore
-  const expected = `[
+  const expect = `[
   ,
   ,
 ${"  "}
 ]`
-  assert({ actual, expected });
+  assert({ actual, expect });
 }
 
 {
   const actual = humanize([Symbol()]);
-  const expected = `[
+  const expect = `[
   Symbol()
 ]`;
-  assert({ actual, expected });
+  assert({ actual, expect });
 }
 
 {
@@ -40,23 +40,23 @@ ${"  "}
 
   {
     const actual = humanize(newArray);
-    const expected = `[
+    const expect = `[
   "foo",
   1
 ]`;
     assert({
       actual,
-      expected,
+      expect,
     });
   }
 
   {
     const actual = humanize(newArray);
-    const expected = `[
+    const expect = `[
   "foo",
   1
 ]`;
-    assert({ actual, expected });
+    assert({ actual, expect });
   }
 }
 
@@ -64,9 +64,9 @@ ${"  "}
   const circularArray = [0];
   circularArray.push(circularArray);
   const actual = humanize(circularArray);
-  const expected = `[
+  const expect = `[
   0,
   Symbol.for('circular')
 ]`;
-  assert({ actual, expected });
+  assert({ actual, expect });
 }

package/src/_tests/js_value/biginit.test.js

@@ -5,32 +5,32 @@ import { humanize } from "@jsenv/humanize";
 {
   const value = BigInt(1);
   const actual = humanize(value);
-  const expected = "1n";
-  assert({ actual, expected });
+  const expect = "1n";
+  assert({ actual, expect });
 }
 
 {
   const value = 2n;
   const actual = humanize(value);
-  const expected = "2n";
-  assert({ actual, expected });
+  const expect = "2n";
+  assert({ actual, expect });
 }
 
 {
   const value = Object(BigInt(1));
   const actual = humanize(value);
-  const expected = "BigInt(1n)";
-  assert({ actual, expected });
+  const expect = "BigInt(1n)";
+  assert({ actual, expect });
 }
 
 {
   const actual = humanize(1234567n);
-  const expected = "1234567n";
-  assert({ actual, expected });
+  const expect = "1234567n";
+  assert({ actual, expect });
 }
 
 {
   const actual = humanize(19223n);
-  const expected = "19223n";
-  assert({ actual, expected });
+  const expect = "19223n";
+  assert({ actual, expect });
 }

package/src/_tests/js_value/boolean.test.js

@@ -3,33 +3,33 @@ import { humanize } from "@jsenv/humanize";
 
 {
   const actual = humanize(true);
-  const expected = "true";
-  assert({ actual, expected });
+  const expect = "true";
+  assert({ actual, expect });
 }
 
 {
   const actual = humanize(false);
-  const expected = "false";
-  assert({ actual, expected });
+  const expect = "false";
+  assert({ actual, expect });
 }
 
 /* eslint-disable no-new-wrappers */
 {
   const actual = humanize(new Boolean(true));
-  const expected = "Boolean(true)";
-  assert({ actual, expected });
+  const expect = "Boolean(true)";
+  assert({ actual, expect });
 }
 
 {
   const actual = humanize(new Boolean(true), { parenthesis: true });
-  const expected = "(Boolean(true))";
-  assert({ actual, expected });
+  const expect = "(Boolean(true))";
+  assert({ actual, expect });
 }
 
 {
   const actual = humanize(new Boolean(true), { useNew: true });
-  const expected = "new Boolean(true)";
-  assert({ actual, expected });
+  const expect = "new Boolean(true)";
+  assert({ actual, expect });
 }
 
 {
@@ -37,9 +37,9 @@ import { humanize } from "@jsenv/humanize";
     parenthesis: true,
     useNew: true,
   });
-  const expected = "new (Boolean(true))";
+  const expect = "new (Boolean(true))";
   assert({
     actual,
-    expected,
+    expect,
   });
 }

package/src/_tests/js_value/date.test.js

@@ -3,13 +3,13 @@ import { humanize } from "@jsenv/humanize";
 
 {
   const actual = humanize(new Date(10));
-  const expected = `Date(10)`;
-  assert({ actual, expected });
+  const expect = `Date(10)`;
+  assert({ actual, expect });
 }
 
 {
   const nowMs = Date.now();
   const actual = humanize(new Date(nowMs));
-  const expected = `Date(${nowMs})`;
-  assert({ actual, expected });
+  const expect = `Date(${nowMs})`;
+  assert({ actual, expect });
 }

package/src/_tests/js_value/error.test.js

@@ -3,14 +3,14 @@ import { humanize } from "@jsenv/humanize";
 
 {
   const actual = humanize(new Error("here"));
-  const expected = `Error("here")`;
-  assert({ actual, expected });
+  const expect = `Error("here")`;
+  assert({ actual, expect });
 }
 
 {
   const actual = humanize(new RangeError("here"));
-  const expected = `RangeError("here")`;
-  assert({ actual, expected });
+  const expect = `RangeError("here")`;
+  assert({ actual, expect });
 }
 
 {
@@ -20,14 +20,14 @@ import { humanize } from "@jsenv/humanize";
     value: "bar",
   });
   const actual = humanize(actualError);
-  const expected = `Error("hello")`;
-  assert({ actual, expected });
+  const expect = `Error("hello")`;
+  assert({ actual, expect });
 }
 
 {
   const error = new Error();
   error.name = "AssertionError";
   const actual = humanize(error);
-  const expected = `Error("")`;
-  assert({ actual, expected });
+  const expect = `Error("")`;
+  assert({ actual, expect });
 }

package/src/_tests/js_value/function.test.js

@@ -5,14 +5,14 @@ import { humanize } from "@jsenv/humanize";
 
 {
   const actual = humanize(function () {});
-  const expected = `function () {/* hidden */}`;
-  assert({ actual, expected });
+  const expect = `function () {/* hidden */}`;
+  assert({ actual, expect });
 }
 
 {
   const actual = humanize(function () {}, { showFunctionBody: true });
-  const expected = "function () {}";
-  assert({ actual, expected });
+  const expect = "function () {}";
+  assert({ actual, expect });
 }
 
 {
@@ -20,8 +20,8 @@ import { humanize } from "@jsenv/humanize";
     return true;
   };
   const actual = humanize(value, { showFunctionBody: true });
-  const expected = value.toString();
-  assert({ actual, expected });
+  const expect = value.toString();
+  assert({ actual, expect });
 }
 
 function named(a) {
@@ -29,13 +29,13 @@ function named(a) {
 }
 {
   const actual = humanize(named);
-  const expected = `function named() {/* hidden */}`;
-  assert({ actual, expected });
+  const expect = `function named() {/* hidden */}`;
+  assert({ actual, expect });
 }
 {
   const actual = humanize(named, { showFunctionBody: true });
-  const expected = named.toString();
-  assert({ actual, expected });
+  const expect = named.toString();
+  assert({ actual, expect });
 }
 
 {
@@ -44,8 +44,8 @@ function named(a) {
     function: function () {},
   };
   const actual = humanize(nested);
-  const expected = `{
+  const expect = `{
   "function": function () {/* hidden */}
 }`;
-  assert({ actual, expected });
+  assert({ actual, expect });
 }

package/src/_tests/js_value/instance.test.js

@@ -6,7 +6,7 @@ const CustomConstructor = function () {
 };
 const customInstance = new CustomConstructor();
 const actual = humanize(customInstance);
-const expected = `CustomConstructor({
+const expect = `CustomConstructor({
   "foo": true
 })`;
-assert({ actual, expected });
+assert({ actual, expect });

package/src/_tests/js_value/null.test.js

@@ -2,5 +2,5 @@ import { assert } from "@jsenv/assert";
 import { humanize } from "@jsenv/humanize";
 
 const actual = humanize(null);
-const expected = "null";
-assert({ actual, expected });
+const expect = "null";
+assert({ actual, expect });

package/src/_tests/js_value/number.test.js

@@ -5,178 +5,178 @@ import { humanize } from "@jsenv/humanize";
 
 {
   const actual = humanize(0);
-  const expected = "0";
-  assert({ actual, expected });
+  const expect = "0";
+  assert({ actual, expect });
 }
 
 {
   const actual = humanize(1);
-  const expected = "1";
-  assert({ actual, expected });
+  const expect = "1";
+  assert({ actual, expect });
 }
 
 {
   const actual = humanize(-0);
-  const expected = "-0";
-  assert({ actual, expected });
+  const expect = "-0";
+  assert({ actual, expect });
 }
 
 {
   const actual = humanize(NaN);
-  const expected = "NaN";
-  assert({ actual, expected });
+  const expect = "NaN";
+  assert({ actual, expect });
 }
 
 {
   const actual = humanize(Infinity);
-  const expected = "Infinity";
-  assert({ actual, expected });
+  const expect = "Infinity";
+  assert({ actual, expect });
 }
 
 {
   const actual = humanize(-Infinity);
-  const expected = "-Infinity";
-  assert({ actual, expected });
+  const expect = "-Infinity";
+  assert({ actual, expect });
 }
 
 {
   // eslint-disable-next-line no-new-wrappers
   const actual = humanize(new Number(0));
-  const expected = "Number(0)";
-  assert({ actual, expected });
+  const expect = "Number(0)";
+  assert({ actual, expect });
 }
 
 {
   // eslint-disable-next-line no-new-wrappers
   const actual = humanize(new Number(0), { parenthesis: true });
-  const expected = "(Number(0))";
-  assert({ actual, expected });
+  const expect = "(Number(0))";
+  assert({ actual, expect });
 }
 
 {
   // eslint-disable-next-line no-new-wrappers
   const actual = humanize(new Number(0), { useNew: true });
-  const expected = "new Number(0)";
-  assert({ actual, expected });
+  const expect = "new Number(0)";
+  assert({ actual, expect });
 }
 
 {
   // eslint-disable-next-line no-new-wrappers
   const actual = humanize(new Number(0), { parenthesis: true, useNew: true });
-  const expected = "new (Number(0))";
-  assert({ actual, expected });
+  const expect = "new (Number(0))";
+  assert({ actual, expect });
 }
 
 // numeric separator - numbers
 {
   const actual = humanize(1235);
-  const expected = "1235";
-  assert({ actual, expected });
+  const expect = "1235";
+  assert({ actual, expect });
 }
 
 {
   const actual = humanize(67000);
-  const expected = "67_000";
-  assert({ actual, expected });
+  const expect = "67_000";
+  assert({ actual, expect });
 }
 
 {
   const actual = humanize(149600000);
-  const expected = "149_600_000";
-  assert({ actual, expected });
+  const expect = "149_600_000";
+  assert({ actual, expect });
 }
 
 {
   const actual = humanize(1_464_301);
-  const expected = "1_464_301";
-  assert({ actual, expected });
+  const expect = "1_464_301";
+  assert({ actual, expect });
 }
 
 // decimal
 {
   const actual = humanize(1234.56);
-  const expected = "1234.56";
-  assert({ actual, expected });
+  const expect = "1234.56";
+  assert({ actual, expect });
 }
 
 {
   const actual = humanize(12345.67);
-  const expected = "12_345.67";
-  assert({ actual, expected });
+  const expect = "12_345.67";
+  assert({ actual, expect });
 }
 
 {
   const actual = humanize(-0.120123);
-  const expected = "-0.120123";
-  assert({ actual, expected });
+  const expect = "-0.120123";
+  assert({ actual, expect });
 }
 
 // negative
 {
   const actual = humanize(-1000001);
-  const expected = "-1_000_001";
-  assert({ actual, expected });
+  const expect = "-1_000_001";
+  assert({ actual, expect });
 }
 
 // exponential
 {
   const actual = humanize(-1.23456e105);
-  const expected = "-1.23456e+105";
-  assert({ actual, expected });
+  const expect = "-1.23456e+105";
+  assert({ actual, expect });
 }
 
 {
   const actual = humanize(-1200000e5);
-  const expected = "-120_000_000_000";
-  assert({ actual, expected });
+  const expect = "-120_000_000_000";
+  assert({ actual, expect });
 }
 
 {
   // prettier-ignore
   const actual = humanize(3.65432E12)
-  const expected = "3_654_320_000_000";
-  assert({ actual, expected });
+  const expect = "3_654_320_000_000";
+  assert({ actual, expect });
 }
 
 // numeric separator - binary
 {
   const actual = humanize(0b10101010101010);
-  const expected = "10_922";
-  assert({ actual, expected });
+  const expect = "10_922";
+  assert({ actual, expect });
 }
 
 {
   // prettier-ignore
   const actual = humanize(0B10101010101010)
-  const expected = "10_922";
-  assert({ actual, expected });
+  const expect = "10_922";
+  assert({ actual, expect });
 }
 
 // numeric separator - hexadecimal
 {
   const actual = humanize(0xfabf00d);
-  const expected = "262_926_349";
-  assert({ actual, expected });
+  const expect = "262_926_349";
+  assert({ actual, expect });
 }
 
 {
   // prettier-ignore
   const actual = humanize(0xABCDEF)
   // prettier-ignore
-  const expected = "11_259_375"
-  assert({ actual, expected });
+  const expect = "11_259_375"
+  assert({ actual, expect });
 }
 
 // numeric separator - octal
 {
   const actual = humanize(0o010101010101);
-  const expected = "1_090_785_345";
-  assert({ actual, expected });
+  const expect = "1_090_785_345";
+  assert({ actual, expect });
 }
 
 {
   // prettier-ignore
   const actual = humanize(0O010101010101)
-  const expected = "1_090_785_345";
-  assert({ actual, expected });
+  const expect = "1_090_785_345";
+  assert({ actual, expect });
 }