@jsenv/humanize 1.0.0 → 1.1.0

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

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

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

package/src/byte/byte.js

@@ -4,7 +4,7 @@ export const humanizeFileSize = (numberOfBytes, { decimals, short } = {}) => {
   return inspectBytes(numberOfBytes, { decimals, short });
 };
 
-export const humanizeMemoryUsage = (metricValue, { decimals, short } = {}) => {
+export const humanizeMemory = (metricValue, { decimals, short } = {}) => {
   return inspectBytes(metricValue, { decimals, fixedDecimals: true, short });
 };
 

package/src/js_value/humanize.js

@@ -65,7 +65,7 @@ export const humanize = (
 
 export const humanizeMethodSymbol = Symbol.for("inspect");
 
-export const humanizeValue = (value, options) => {
+const humanizeValue = (value, options) => {
   const customHumanize = value && value[humanizeMethodSymbol];
   if (customHumanize) {
     return customHumanize(options);

package/src/log/ansi_browser.js

@@ -0,0 +1,27 @@
+// https://github.com/Marak/colors.js/blob/master/lib/styles.js
+// https://stackoverflow.com/a/75985833/2634179
+const RESET = "\x1b[0m";
+
+export const ANSI = {
+  supported: true,
+
+  RED: "\x1b[31m",
+  GREEN: "\x1b[32m",
+  YELLOW: "\x1b[33m",
+  BLUE: "\x1b[34m",
+  MAGENTA: "\x1b[35m",
+  CYAN: "\x1b[36m",
+  GREY: "\x1b[90m",
+  color: (text, ANSI_COLOR) => {
+    return ANSI.supported && ANSI_COLOR ? `${ANSI_COLOR}${text}${RESET}` : text;
+  },
+
+  BOLD: "\x1b[1m",
+  UNDERLINE: "\x1b[4m",
+  STRIKE: "\x1b[9m",
+  effect: (text, ANSI_EFFECT) => {
+    return ANSI.supported && ANSI_EFFECT
+      ? `${ANSI_EFFECT}${text}${RESET}`
+      : text;
+  },
+};

package/src/log/{ansi.js → ansi_node.js}

@@ -13,14 +13,19 @@ export const ANSI = {
   YELLOW: "\x1b[33m",
   BLUE: "\x1b[34m",
   MAGENTA: "\x1b[35m",
+  CYAN: "\x1b[36m",
   GREY: "\x1b[90m",
   color: (text, ANSI_COLOR) => {
-    return ANSI.supported ? `${ANSI_COLOR}${text}${RESET}` : text;
+    return ANSI.supported && ANSI_COLOR ? `${ANSI_COLOR}${text}${RESET}` : text;
   },
 
   BOLD: "\x1b[1m",
+  UNDERLINE: "\x1b[4m",
+  STRIKE: "\x1b[9m",
   effect: (text, ANSI_EFFECT) => {
-    return ANSI.supported ? `${ANSI_EFFECT}${text}${RESET}` : text;
+    return ANSI.supported && ANSI_EFFECT
+      ? `${ANSI_EFFECT}${text}${RESET}`
+      : text;
   },
 };
 

package/src/log/dynamic_log.js

@@ -88,20 +88,22 @@ export const createDynamicLog = ({
     clearAttemptResult = undefined;
   };
 
-  const clearDuringFunctionCall = (callback) => {
+  const clearDuringFunctionCall = (
+    callback,
+    ouputAfterCallback = lastOutput,
+  ) => {
     // 1. Erase the current log
-    // 2. Call callback (expected to write something on stdout)
+    // 2. Call callback (expect to write something on stdout)
     // 3. Restore the current log
     // During step 2. we expect a "write from outside" so we uninstall
     // the stream spy during function call
-    const currentOutput = lastOutput;
     update("");
 
     writing = true;
     callback();
     writing = false;
 
-    update(currentOutput);
+    update(ouputAfterCallback);
   };
 
   const writeFromOutsideEffect = (value) => {

package/src/log/spinner.js

@@ -1,4 +1,4 @@
-import { ANSI } from "./ansi.js";
+import { ANSI } from "./ansi_node.js";
 
 export const startSpinner = ({
   dynamicLog,

package/src/log/task_log.js

@@ -1,5 +1,5 @@
 import { humanizeDuration } from "../time/time.js";
-import { UNICODE } from "./unicode.js";
+import { UNICODE } from "./unicode_node.js";
 import { createDynamicLog } from "./dynamic_log.js";
 import { startSpinner } from "./spinner.js";
 

package/src/log/unicode_browser.js

@@ -0,0 +1,53 @@
+// see also https://github.com/sindresorhus/figures
+
+import { ANSI } from "./ansi_browser.js";
+
+export const UNICODE = {
+  supported: true,
+
+  get COMMAND_RAW() {
+    return UNICODE.supported ? `❯` : `>`;
+  },
+  get OK_RAW() {
+    return UNICODE.supported ? `✔` : `√`;
+  },
+  get FAILURE_RAW() {
+    return UNICODE.supported ? `✖` : `×`;
+  },
+  get DEBUG_RAW() {
+    return UNICODE.supported ? `◆` : `♦`;
+  },
+  get INFO_RAW() {
+    return UNICODE.supported ? `ℹ` : `i`;
+  },
+  get WARNING_RAW() {
+    return UNICODE.supported ? `⚠` : `‼`;
+  },
+  get CIRCLE_CROSS_RAW() {
+    return UNICODE.supported ? `ⓧ` : `(×)`;
+  },
+  get COMMAND() {
+    return ANSI.color(UNICODE.COMMAND_RAW, ANSI.GREY); // ANSI_MAGENTA)
+  },
+  get OK() {
+    return ANSI.color(UNICODE.OK_RAW, ANSI.GREEN);
+  },
+  get FAILURE() {
+    return ANSI.color(UNICODE.FAILURE_RAW, ANSI.RED);
+  },
+  get DEBUG() {
+    return ANSI.color(UNICODE.DEBUG_RAW, ANSI.GREY);
+  },
+  get INFO() {
+    return ANSI.color(UNICODE.INFO_RAW, ANSI.BLUE);
+  },
+  get WARNING() {
+    return ANSI.color(UNICODE.WARNING_RAW, ANSI.YELLOW);
+  },
+  get CIRCLE_CROSS() {
+    return ANSI.color(UNICODE.CIRCLE_CROSS_RAW, ANSI.RED);
+  },
+  get ELLIPSIS() {
+    return UNICODE.supported ? `…` : `...`;
+  },
+};

package/src/log/{unicode.js → unicode_node.js}

@@ -2,7 +2,7 @@
 
 import isUnicodeSupported from "is-unicode-supported";
 
-import { ANSI } from "./ansi.js";
+import { ANSI } from "./ansi_node.js";
 
 export const UNICODE = {
   supported: isUnicodeSupported(),
@@ -49,4 +49,7 @@ export const UNICODE = {
   get CIRCLE_CROSS() {
     return ANSI.color(UNICODE.CIRCLE_CROSS_RAW, ANSI.RED);
   },
+  get ELLIPSIS() {
+    return UNICODE.supported ? `…` : `...`;
+  },
 };