@jsenv/humanize 1.0.0

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

@@ -0,0 +1,182 @@
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/test/numeric-separators-style.mjs
+
+import { assert } from "@jsenv/assert";
+import { humanize } from "@jsenv/humanize";
+
+{
+  const actual = humanize(0);
+  const expected = "0";
+  assert({ actual, expected });
+}
+
+{
+  const actual = humanize(1);
+  const expected = "1";
+  assert({ actual, expected });
+}
+
+{
+  const actual = humanize(-0);
+  const expected = "-0";
+  assert({ actual, expected });
+}
+
+{
+  const actual = humanize(NaN);
+  const expected = "NaN";
+  assert({ actual, expected });
+}
+
+{
+  const actual = humanize(Infinity);
+  const expected = "Infinity";
+  assert({ actual, expected });
+}
+
+{
+  const actual = humanize(-Infinity);
+  const expected = "-Infinity";
+  assert({ actual, expected });
+}
+
+{
+  // eslint-disable-next-line no-new-wrappers
+  const actual = humanize(new Number(0));
+  const expected = "Number(0)";
+  assert({ actual, expected });
+}
+
+{
+  // eslint-disable-next-line no-new-wrappers
+  const actual = humanize(new Number(0), { parenthesis: true });
+  const expected = "(Number(0))";
+  assert({ actual, expected });
+}
+
+{
+  // eslint-disable-next-line no-new-wrappers
+  const actual = humanize(new Number(0), { useNew: true });
+  const expected = "new Number(0)";
+  assert({ actual, expected });
+}
+
+{
+  // 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 });
+}
+
+// numeric separator - numbers
+{
+  const actual = humanize(1235);
+  const expected = "1235";
+  assert({ actual, expected });
+}
+
+{
+  const actual = humanize(67000);
+  const expected = "67_000";
+  assert({ actual, expected });
+}
+
+{
+  const actual = humanize(149600000);
+  const expected = "149_600_000";
+  assert({ actual, expected });
+}
+
+{
+  const actual = humanize(1_464_301);
+  const expected = "1_464_301";
+  assert({ actual, expected });
+}
+
+// decimal
+{
+  const actual = humanize(1234.56);
+  const expected = "1234.56";
+  assert({ actual, expected });
+}
+
+{
+  const actual = humanize(12345.67);
+  const expected = "12_345.67";
+  assert({ actual, expected });
+}
+
+{
+  const actual = humanize(-0.120123);
+  const expected = "-0.120123";
+  assert({ actual, expected });
+}
+
+// negative
+{
+  const actual = humanize(-1000001);
+  const expected = "-1_000_001";
+  assert({ actual, expected });
+}
+
+// exponential
+{
+  const actual = humanize(-1.23456e105);
+  const expected = "-1.23456e+105";
+  assert({ actual, expected });
+}
+
+{
+  const actual = humanize(-1200000e5);
+  const expected = "-120_000_000_000";
+  assert({ actual, expected });
+}
+
+{
+  // prettier-ignore
+  const actual = humanize(3.65432E12)
+  const expected = "3_654_320_000_000";
+  assert({ actual, expected });
+}
+
+// numeric separator - binary
+{
+  const actual = humanize(0b10101010101010);
+  const expected = "10_922";
+  assert({ actual, expected });
+}
+
+{
+  // prettier-ignore
+  const actual = humanize(0B10101010101010)
+  const expected = "10_922";
+  assert({ actual, expected });
+}
+
+// numeric separator - hexadecimal
+{
+  const actual = humanize(0xfabf00d);
+  const expected = "262_926_349";
+  assert({ actual, expected });
+}
+
+{
+  // prettier-ignore
+  const actual = humanize(0xABCDEF)
+  // prettier-ignore
+  const expected = "11_259_375"
+  assert({ actual, expected });
+}
+
+// numeric separator - octal
+{
+  const actual = humanize(0o010101010101);
+  const expected = "1_090_785_345";
+  assert({ actual, expected });
+}
+
+{
+  // prettier-ignore
+  const actual = humanize(0O010101010101)
+  const expected = "1_090_785_345";
+  assert({ actual, expected });
+}

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

@@ -0,0 +1,173 @@
+import { assert } from "@jsenv/assert";
+import { humanize } from "@jsenv/humanize";
+
+{
+  const actual = humanize({});
+  const expected = "{}";
+  assert({ actual, expected });
+}
+
+{
+  // eslint-disable-next-line no-new-object
+  const actual = humanize(new Object({}));
+  const expected = "{}";
+  assert({ actual, expected });
+}
+
+{
+  const actual = humanize({}, { objectConstructor: true });
+  const expected = "Object({})";
+  assert({ actual, expected });
+}
+
+{
+  const actual = humanize(
+    { foo: true },
+    { objectConstructor: true, useNew: true },
+  );
+  const expected = `new Object({
+  "foo": true
+})`;
+  assert({
+    actual,
+    expected,
+  });
+}
+
+{
+  const actual = humanize({ 0: "foo" });
+  const expected = `{
+  0: "foo"
+}`;
+  assert({ actual, expected });
+}
+
+{
+  const actual = humanize({ Infinity: "foo" });
+  const expected = `{
+  "Infinity": "foo"
+}`;
+  assert({ actual, expected });
+}
+
+{
+  const actual = humanize({ name: "dam" }, { quote: "'" });
+  const expected = `{
+  'name': 'dam'
+}`;
+  assert({ actual, expected });
+}
+
+{
+  const actual = humanize(
+    { foo: true, nested: { bar: true } },
+    { parenthesis: true },
+  );
+  const expected = `({
+  "foo": true,
+  "nested": ({
+    "bar": true
+  })
+})`;
+  assert({ actual, expected });
+}
+
+{
+  const foo = { foo: true, bar: false };
+
+  const actual = humanize(foo);
+  const expected = `{
+  "foo": true,
+  "bar": false
+}`;
+  assert({ actual, expected });
+}
+
+{
+  const actual = humanize(
+    Object.create({
+      foo: true,
+    }),
+  );
+  const expected = "{}";
+  assert({ actual, expected });
+}
+
+{
+  const nested = { foo: { name: "dam" } };
+  const actual = humanize(nested);
+  const expected = `{
+  "foo": {
+    "name": "dam"
+  }
+}`;
+  assert({ actual, expected });
+}
+
+{
+  const circularObject = {
+    foo: true,
+  };
+  circularObject.self = circularObject;
+  const actual = humanize(circularObject);
+  const expected = `{
+  "foo": true,
+  "self": Symbol.for('circular')
+}`;
+  assert({ actual, expected });
+}
+
+{
+  const nestedCircularObject = {
+    foo: true,
+  };
+  nestedCircularObject.nested = {
+    bar: true,
+    parent: nestedCircularObject,
+  };
+  const actual = humanize(nestedCircularObject);
+  const expected = `{
+  "foo": true,
+  "nested": {
+    "bar": true,
+    "parent": Symbol.for('circular')
+  }
+}`;
+  assert({ actual, expected });
+}
+
+{
+  const actual = humanize(Object.create(null));
+  const expected = "{}";
+  assert({ actual, expected });
+}
+
+{
+  const object = Object.create(null);
+  object[Symbol.toStringTag] = "stuff";
+  const actual = humanize(object);
+  const expected = `{
+  [Symbol("Symbol.toStringTag")]: "stuff"
+}`;
+  assert({ actual, expected });
+}
+
+{
+  const object = Object.create(null);
+  object[Symbol.toStringTag] = "stuff";
+  object.foo = true;
+  const actual = humanize(object);
+  const expected = `{
+  "foo": true,
+  [Symbol("Symbol.toStringTag")]: "stuff"
+}`;
+  assert({ actual, expected });
+}
+
+{
+  const actual = humanize({ [Symbol()]: true });
+  const expected = `{
+  [Symbol()]: true
+}`;
+  assert({ actual, expected });
+}

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

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

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

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

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

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

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

@@ -0,0 +1,6 @@
+import { assert } from "@jsenv/assert";
+import { humanize } from "@jsenv/humanize";
+
+const actual = humanize(undefined);
+const expected = "undefined";
+assert({ actual, expected });

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

@@ -0,0 +1,39 @@
+// must be verfied by human eyes
+// depending on terminal height
+// either the whole log can be rewritten (updated)
+// or it will be kept and second log appended at the bottom
+
+import { createDynamicLog } from "@jsenv/humanize";
+
+const log = createDynamicLog();
+log.update(`
+1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18`);
+log.update(`
+a
+b
+c
+d
+e
+f
+g`);
+log.update(`
+alpha
+beta
+gamma`);

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

@@ -0,0 +1,7 @@
+import { createDynamicLog } from "@jsenv/humanize";
+
+const dynamicLog = createDynamicLog();
+dynamicLog.update("hello");
+console.log("hey");
+dynamicLog.update("world");
+dynamicLog.update("!");

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

@@ -0,0 +1,91 @@
+import { assert } from "@jsenv/assert";
+
+import { createLogger } from "@jsenv/humanize";
+
+try {
+  createLogger({ logLevel: "foo" });
+  throw new Error("should throw");
+} catch (actual) {
+  const expected = new Error(`unexpected logLevel.
+--- logLevel ---
+foo
+--- allowed log levels ---
+off
+error
+warn
+info
+debug`);
+  assert({ actual, expected });
+}
+
+{
+  const logger = createLogger();
+  const actual = logger.levels;
+  const expected = {
+    debug: false,
+    info: true,
+    warn: true,
+    error: true,
+  };
+  assert({ actual, expected });
+}
+
+{
+  const logger = createLogger({ logLevel: "off" });
+  const actual = logger.levels;
+  const expected = {
+    debug: false,
+    info: false,
+    warn: false,
+    error: false,
+  };
+  assert({ actual, expected });
+}
+
+{
+  const logger = createLogger({ logLevel: "debug" });
+  const actual = logger.levels;
+  const expected = {
+    debug: true,
+    info: true,
+    warn: true,
+    error: true,
+  };
+  assert({ actual, expected });
+}
+
+{
+  const logger = createLogger({ logLevel: "info" });
+  const actual = logger.levels;
+  const expected = {
+    debug: false,
+    info: true,
+    warn: true,
+    error: true,
+  };
+  assert({ actual, expected });
+}
+
+{
+  const logger = createLogger({ logLevel: "warn" });
+  const actual = logger.levels;
+  const expected = {
+    debug: false,
+    info: false,
+    warn: true,
+    error: true,
+  };
+  assert({ actual, expected });
+}
+
+{
+  const logger = createLogger({ logLevel: "error" });
+  const actual = logger.levels;
+  const expected = {
+    debug: false,
+    info: false,
+    warn: false,
+    error: true,
+  };
+  assert({ actual, expected });
+}

package/src/_tests/log/spinner.duration.test_manual.mjs

@@ -0,0 +1,25 @@
+import { createDynamicLog, startSpinner } from "@jsenv/humanize";
+
+const dynamicLog = createDynamicLog();
+const startMs = Date.now();
+let msDuration = 0;
+let text = "Doing something";
+const spinner = startSpinner({
+  dynamicLog,
+  render: () => text,
+  effect: () => {
+    const intervalId = setInterval(() => {
+      msDuration = Date.now() - startMs;
+      text = `Doing something ${msDuration} ms`;
+    }, 100);
+    return () => {
+      clearInterval(intervalId);
+    };
+  },
+});
+await new Promise((resolve) => setTimeout(resolve, 2500));
+
+spinner.stop("Done");
+console.log(`Done in ${msDuration} ms`);
+
+await new Promise((resolve) => setTimeout(resolve, 500));

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

@@ -0,0 +1,33 @@
+// import { assert } from "@jsenv/assert"
+
+// import { startSpinner } from "@jsenv/humanize"
+// import { spyStreamOutput } from "@jsenv/humanize/src/internal/spy_stream_output.js"
+
+// let getOutput = spyStreamOutput(process.stdout)
+// startSpinner({
+//   frames: ["a", "b"],
+//   text: "loading",
+//   fps: 1,
+// })
+
+// {
+//   const actual = getOutput()
+//   const expected = `a loading\n`
+//   assert({ actual, expected })
+// }
+// getOutput = spyStreamOutput(process.stdout)
+// await new Promise((resolve) => setTimeout(resolve, 1500))
+
+// {
+//   const actual = getOutput()
+//   const expected = `b loading\n`
+//   assert({ actual, expected })
+// }
+// getOutput = spyStreamOutput(process.stdout)
+// await new Promise((resolve) => setTimeout(resolve, 1500))
+
+// {
+//   const actual = getOutput()
+//   const expected = `a loading\n`
+//   assert({ actual, expected })
+// }

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

@@ -0,0 +1,15 @@
+import { createDynamicLog, startSpinner } from "@jsenv/humanize";
+
+const dynamicLog = createDynamicLog();
+const spinner = startSpinner({
+  dynamicLog,
+  render: () => "Loading and I would say even more",
+  stopOnWriteFromOutside: true,
+});
+
+await new Promise((resolve) => setTimeout(resolve, 2500));
+
+dynamicLog.update("Hey");
+spinner.stop();
+
+await new Promise((resolve) => setTimeout(resolve, 500));