@jsenv/humanize 1.0.0 → 1.1.1

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

@@ -3,21 +3,21 @@ import { humanize } from "@jsenv/humanize";
 
 {
   const actual = humanize({});
-  const expected = "{}";
-  assert({ actual, expected });
+  const expect = "{}";
+  assert({ actual, expect });
 }
 
 {
   // eslint-disable-next-line no-new-object
   const actual = humanize(new Object({}));
-  const expected = "{}";
-  assert({ actual, expected });
+  const expect = "{}";
+  assert({ actual, expect });
 }
 
 {
   const actual = humanize({}, { objectConstructor: true });
-  const expected = "Object({})";
-  assert({ actual, expected });
+  const expect = "Object({})";
+  assert({ actual, expect });
 }
 
 {
@@ -25,37 +25,37 @@ import { humanize } from "@jsenv/humanize";
     { foo: true },
     { objectConstructor: true, useNew: true },
   );
-  const expected = `new Object({
+  const expect = `new Object({
   "foo": true
 })`;
   assert({
     actual,
-    expected,
+    expect,
   });
 }
 
 {
   const actual = humanize({ 0: "foo" });
-  const expected = `{
+  const expect = `{
   0: "foo"
 }`;
-  assert({ actual, expected });
+  assert({ actual, expect });
 }
 
 {
   const actual = humanize({ Infinity: "foo" });
-  const expected = `{
+  const expect = `{
   "Infinity": "foo"
 }`;
-  assert({ actual, expected });
+  assert({ actual, expect });
 }
 
 {
   const actual = humanize({ name: "dam" }, { quote: "'" });
-  const expected = `{
+  const expect = `{
   'name': 'dam'
 }`;
-  assert({ actual, expected });
+  assert({ actual, expect });
 }
 
 {
@@ -63,24 +63,24 @@ import { humanize } from "@jsenv/humanize";
     { foo: true, nested: { bar: true } },
     { parenthesis: true },
   );
-  const expected = `({
+  const expect = `({
   "foo": true,
   "nested": ({
     "bar": true
   })
 })`;
-  assert({ actual, expected });
+  assert({ actual, expect });
 }
 
 {
   const foo = { foo: true, bar: false };
 
   const actual = humanize(foo);
-  const expected = `{
+  const expect = `{
   "foo": true,
   "bar": false
 }`;
-  assert({ actual, expected });
+  assert({ actual, expect });
 }
 
 {
@@ -89,19 +89,19 @@ import { humanize } from "@jsenv/humanize";
       foo: true,
     }),
   );
-  const expected = "{}";
-  assert({ actual, expected });
+  const expect = "{}";
+  assert({ actual, expect });
 }
 
 {
   const nested = { foo: { name: "dam" } };
   const actual = humanize(nested);
-  const expected = `{
+  const expect = `{
   "foo": {
     "name": "dam"
   }
 }`;
-  assert({ actual, expected });
+  assert({ actual, expect });
 }
 
 {
@@ -110,11 +110,11 @@ import { humanize } from "@jsenv/humanize";
   };
   circularObject.self = circularObject;
   const actual = humanize(circularObject);
-  const expected = `{
+  const expect = `{
   "foo": true,
   "self": Symbol.for('circular')
 }`;
-  assert({ actual, expected });
+  assert({ actual, expect });
 }
 
 {
@@ -126,30 +126,30 @@ import { humanize } from "@jsenv/humanize";
     parent: nestedCircularObject,
   };
   const actual = humanize(nestedCircularObject);
-  const expected = `{
+  const expect = `{
   "foo": true,
   "nested": {
     "bar": true,
     "parent": Symbol.for('circular')
   }
 }`;
-  assert({ actual, expected });
+  assert({ actual, expect });
 }
 
 {
   const actual = humanize(Object.create(null));
-  const expected = "{}";
-  assert({ actual, expected });
+  const expect = "{}";
+  assert({ actual, expect });
 }
 
 {
   const object = Object.create(null);
   object[Symbol.toStringTag] = "stuff";
   const actual = humanize(object);
-  const expected = `{
+  const expect = `{
   [Symbol("Symbol.toStringTag")]: "stuff"
 }`;
-  assert({ actual, expected });
+  assert({ actual, expect });
 }
 
 {
@@ -157,17 +157,17 @@ import { humanize } from "@jsenv/humanize";
   object[Symbol.toStringTag] = "stuff";
   object.foo = true;
   const actual = humanize(object);
-  const expected = `{
+  const expect = `{
   "foo": true,
   [Symbol("Symbol.toStringTag")]: "stuff"
 }`;
-  assert({ actual, expected });
+  assert({ actual, expect });
 }
 
 {
   const actual = humanize({ [Symbol()]: true });
-  const expected = `{
+  const expect = `{
   [Symbol()]: true
 }`;
-  assert({ actual, expected });
+  assert({ actual, expect });
 }

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

@@ -3,12 +3,12 @@ import { humanize } from "@jsenv/humanize";
 
 {
   const actual = humanize(/ok/g);
-  const expected = "/ok/g";
-  assert({ actual, expected });
+  const expect = "/ok/g";
+  assert({ actual, expect });
 }
 
 {
   const actual = humanize(new RegExp("foo", "g"));
-  const expected = "/foo/g";
-  assert({ actual, expected });
+  const expect = "/foo/g";
+  assert({ actual, expect });
 }

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

@@ -3,104 +3,104 @@ import { humanize } from "@jsenv/humanize";
 
 {
   const actual = humanize(String.fromCharCode(127));
-  const expected = `"\\x7F"`;
-  assert({ actual, expected });
+  const expect = `"\\x7F"`;
+  assert({ actual, expect });
 }
 
 {
   const actual = humanize("");
-  const expected = `""`;
-  assert({ actual, expected });
+  const expect = `""`;
+  assert({ actual, expect });
 }
 
 {
   const actual = humanize("dam");
-  const expected = `"dam"`;
-  assert({ actual, expected });
+  const expect = `"dam"`;
+  assert({ actual, expect });
 }
 
 {
   const actual = humanize("don't");
-  const expected = `"don't"`;
-  assert({ actual, expected });
+  const expect = `"don't"`;
+  assert({ actual, expect });
 }
 
 {
   const actual = humanize("don't", { quote: "'" });
-  const expected = `'don\\\'t'`;
-  assert({ actual, expected });
+  const expect = `'don\\\'t'`;
+  assert({ actual, expect });
 }
 
 {
   const actual = humanize(`his name is "dam"`);
-  const expected = `'his name is "dam"'`;
-  assert({ actual, expected });
+  const expect = `'his name is "dam"'`;
+  assert({ actual, expect });
 }
 
 {
   const actual = humanize(`his name is "dam"`, { quote: "'" });
-  const expected = `'his name is "dam"'`;
-  assert({ actual, expected });
+  const expect = `'his name is "dam"'`;
+  assert({ actual, expect });
 }
 
 {
   const actual = humanize("a\nb");
-  const expected = `"a\\nb"`;
-  assert({ actual, expected });
+  const expect = `"a\\nb"`;
+  assert({ actual, expect });
 }
 
 {
   const actual = humanize("a\rb");
-  const expected = `"a\\rb"`;
-  assert({ actual, expected });
+  const expect = `"a\\rb"`;
+  assert({ actual, expect });
 }
 
 {
   const actual = humanize("a\u2028b");
-  const expected = `"a\\u2028b"`;
-  assert({ actual, expected });
+  const expect = `"a\\u2028b"`;
+  assert({ actual, expect });
 }
 
 {
   const actual = humanize("a\u2029b");
-  const expected = `"a\\u2029b"`;
-  assert({ actual, expected });
+  const expect = `"a\\u2029b"`;
+  assert({ actual, expect });
 }
 
 {
   // eslint-disable-next-line no-new-wrappers
   const actual = humanize(new String(""));
-  const expected = `String("")`;
+  const expect = `String("")`;
   assert({
     actual,
-    expected,
+    expect,
   });
 }
 
 {
   // eslint-disable-next-line no-new-wrappers
   const actual = humanize(new String("dam"));
-  const expected = `String("dam")`;
+  const expect = `String("dam")`;
   assert({
     actual,
-    expected,
+    expect,
   });
 }
 
 {
   const actual = humanize("dam", { quote: "'" });
-  const expected = `'dam'`;
-  assert({ actual, expected });
+  const expect = `'dam'`;
+  assert({ actual, expect });
 }
 
 {
   const actual = humanize(`\`"'`);
-  const expected = `"\`\\\"'"`;
-  assert({ actual, expected });
+  const expect = `"\`\\\"'"`;
+  assert({ actual, expect });
 }
 
 {
   const actual = humanize(`""''`);
-  const expected = `\`""''\``;
-  assert({ actual, expected });
+  const expect = `\`""''\``;
+  assert({ actual, expect });
 }

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

@@ -3,18 +3,18 @@ import { humanize } from "@jsenv/humanize";
 
 {
   const actual = humanize(Symbol());
-  const expected = "Symbol()";
-  assert({ actual, expected });
+  const expect = "Symbol()";
+  assert({ actual, expect });
 }
 
 {
   const actual = humanize(Symbol("foo"));
-  const expected = `Symbol("foo")`;
-  assert({ actual, expected });
+  const expect = `Symbol("foo")`;
+  assert({ actual, expect });
 }
 
 {
   const actual = humanize(Symbol(42));
-  const expected = `Symbol("42")`;
-  assert({ actual, expected });
+  const expect = `Symbol("42")`;
+  assert({ actual, expect });
 }

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

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

package/src/_tests/log/logger.test.mjs

@@ -6,7 +6,7 @@ try {
   createLogger({ logLevel: "foo" });
   throw new Error("should throw");
 } catch (actual) {
-  const expected = new Error(`unexpected logLevel.
+  const expect = new Error(`unexpected logLevel.
 --- logLevel ---
 foo
 --- allowed log levels ---
@@ -15,77 +15,77 @@ error
 warn
 info
 debug`);
-  assert({ actual, expected });
+  assert({ actual, expect });
 }
 
 {
   const logger = createLogger();
   const actual = logger.levels;
-  const expected = {
+  const expect = {
     debug: false,
     info: true,
     warn: true,
     error: true,
   };
-  assert({ actual, expected });
+  assert({ actual, expect });
 }
 
 {
   const logger = createLogger({ logLevel: "off" });
   const actual = logger.levels;
-  const expected = {
+  const expect = {
     debug: false,
     info: false,
     warn: false,
     error: false,
   };
-  assert({ actual, expected });
+  assert({ actual, expect });
 }
 
 {
   const logger = createLogger({ logLevel: "debug" });
   const actual = logger.levels;
-  const expected = {
+  const expect = {
     debug: true,
     info: true,
     warn: true,
     error: true,
   };
-  assert({ actual, expected });
+  assert({ actual, expect });
 }
 
 {
   const logger = createLogger({ logLevel: "info" });
   const actual = logger.levels;
-  const expected = {
+  const expect = {
     debug: false,
     info: true,
     warn: true,
     error: true,
   };
-  assert({ actual, expected });
+  assert({ actual, expect });
 }
 
 {
   const logger = createLogger({ logLevel: "warn" });
   const actual = logger.levels;
-  const expected = {
+  const expect = {
     debug: false,
     info: false,
     warn: true,
     error: true,
   };
-  assert({ actual, expected });
+  assert({ actual, expect });
 }
 
 {
   const logger = createLogger({ logLevel: "error" });
   const actual = logger.levels;
-  const expected = {
+  const expect = {
     debug: false,
     info: false,
     warn: false,
     error: true,
   };
-  assert({ actual, expected });
+  assert({ actual, expect });
 }

package/src/_tests/log/spinner.test.mjs

@@ -12,22 +12,22 @@
 
 // {
 //   const actual = getOutput()
-//   const expected = `a loading\n`
-//   assert({ actual, expected })
+//   const expect = `a loading\n`
+//   assert({ actual, expect })
 // }
 // getOutput = spyStreamOutput(process.stdout)
 // await new Promise((resolve) => setTimeout(resolve, 1500))
 
 // {
 //   const actual = getOutput()
-//   const expected = `b loading\n`
-//   assert({ actual, expected })
+//   const expect = `b loading\n`
+//   assert({ actual, expect })
 // }
 // getOutput = spyStreamOutput(process.stdout)
 // await new Promise((resolve) => setTimeout(resolve, 1500))
 
 // {
 //   const actual = getOutput()
-//   const expected = `a loading\n`
-//   assert({ actual, expected })
+//   const expect = `a loading\n`
+//   assert({ actual, expect })
 // }

package/src/_tests/percentage/percentage_distribution.test.mjs

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

package/src/_tests/time/decimals.test.js

@@ -11,109 +11,109 @@ import {
 // rounds last decimal
 {
   const actual = setRoundedPrecision(0.54);
-  const expected = 0.5;
-  assert({ actual, expected });
+  const expect = 0.5;
+  assert({ actual, expect });
 }
 {
   const actual = setRoundedPrecision(0.55);
-  const expected = 0.6;
-  assert({ actual, expected });
+  const expect = 0.6;
+  assert({ actual, expect });
 }
 // floor last decimal
 {
   const actual = setFlooredPrecision(0.54);
-  const expected = 0.5;
-  assert({ actual, expected });
+  const expect = 0.5;
+  assert({ actual, expect });
 }
 {
   const actual = setFlooredPrecision(0.55);
-  const expected = 0.5;
-  assert({ actual, expected });
+  const expect = 0.5;
+  assert({ actual, expect });
 }
 {
   const actual = setFlooredPrecision(0.501);
-  const expected = 0.5;
-  assert({ actual, expected });
+  const expect = 0.5;
+  assert({ actual, expect });
 }
 // ceil last decimal
 {
   const actual = setCeiledPrecision(0.54);
-  const expected = 0.6;
-  assert({ actual, expected });
+  const expect = 0.6;
+  assert({ actual, expect });
 }
 {
   const actual = setCeiledPrecision(0.54);
-  const expected = 0.6;
-  assert({ actual, expected });
+  const expect = 0.6;
+  assert({ actual, expect });
 }
 {
   const actual = setCeiledPrecision(0.501);
-  const expected = 0.6;
-  assert({ actual, expected });
+  const expect = 0.6;
+  assert({ actual, expect });
 }
 // truncate last decimal
 {
   const actual = setPrecision(0.501);
-  const expected = 0.5;
-  assert({ actual, expected });
+  const expect = 0.5;
+  assert({ actual, expect });
 }
 {
   const actual = setPrecision(0.56);
-  const expected = 0.5;
-  assert({ actual, expected });
+  const expect = 0.5;
+  assert({ actual, expect });
 }
 // rounded tests
 {
   const actual = setRoundedPrecision(0.0101);
-  const expected = 0.01;
-  assert({ actual, expected });
+  const expect = 0.01;
+  assert({ actual, expect });
 }
 {
   const actual = setRoundedPrecision(0.012);
-  const expected = 0.01;
-  assert({ actual, expected });
+  const expect = 0.01;
+  assert({ actual, expect });
 }
 {
   const actual = setRoundedPrecision(0.016);
-  const expected = 0.02;
-  assert({ actual, expected });
+  const expect = 0.02;
+  assert({ actual, expect });
 }
 {
   const actual = setRoundedPrecision(0.016556, {
     decimals: 3,
   });
-  const expected = 0.0166;
-  assert({ actual, expected });
+  const expect = 0.0166;
+  assert({ actual, expect });
 }
 {
   const actual = setRoundedPrecision(0);
-  const expected = 0;
-  assert({ actual, expected });
+  const expect = 0;
+  assert({ actual, expect });
 }
 {
   const actual = setRoundedPrecision(-0.0015);
-  const expected = -0.002;
-  assert({ actual, expected });
+  const expect = -0.002;
+  assert({ actual, expect });
 }
 
 /* numbers above 1 */
 {
   const actual = setRoundedPrecision(37.04);
-  const expected = 37;
-  assert({ actual, expected });
+  const expect = 37;
+  assert({ actual, expect });
 }
 {
   const actual = setRoundedPrecision(37.05);
-  const expected = 37.1;
-  assert({ actual, expected });
+  const expect = 37.1;
+  assert({ actual, expect });
 }
 {
   const actual = setCeiledPrecision(37.01);
-  const expected = 37.1;
-  assert({ actual, expected });
+  const expect = 37.1;
+  assert({ actual, expect });
 }
 {
   const actual = setFlooredPrecision(37.01);
-  const expected = 37;
-  assert({ actual, expected });
+  const expect = 37;
+  assert({ actual, expect });
 }

package/src/_tests/time/duration.test.js

@@ -2,9 +2,9 @@ import { assert } from "@jsenv/assert";
 
 import { humanizeDuration } from "@jsenv/humanize";
 
-const test = (durationInMs, expected) => {
+const test = (durationInMs, expect) => {
   const actual = humanizeDuration(durationInMs);
-  assert({ actual, expected });
+  assert({ actual, expect });
 };
 
 test(0.1, "0 second");