@jsenv/humanize 1.0.0 → 1.1.0

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 });
 }

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 });
 }