@jsenv/humanize 1.0.0

package/src/js_value/humanize.js

@@ -0,0 +1,140 @@
+// primitives
+import { inspectBoolean } from "./boolean.js";
+import { inspectNull } from "./null.js";
+import { inspectNumber } from "./number.js";
+import { inspectString } from "./string.js";
+import { inspectSymbol } from "./symbol.js";
+import { inspectUndefined } from "./undefined.js";
+import { inspectBigInt } from "./bigint.js";
+import { inspectArray } from "./array.js";
+// composites
+import { inspectBigIntObject } from "./bigint_object.js";
+import { inspectBooleanObject } from "./boolean_object.js";
+import { inspectError } from "./error.js";
+import { inspectDate } from "./date.js";
+import { inspectFunction } from "./function.js";
+import { inspectNumberObject } from "./number_object.js";
+import { inspectObject } from "./object.js";
+import { inspectRegExp } from "./regexp.js";
+import { inspectStringObject } from "./string_object.js";
+import { inspectConstructor } from "./constructor.js";
+
+export const humanize = (
+  value,
+  {
+    parenthesis = false,
+    quote = "auto",
+    canUseTemplateString = true,
+    useNew = false,
+    objectConstructor = false,
+    showFunctionBody = false,
+    indentUsingTab = false,
+    indentSize = 2,
+    numericSeparator = true,
+    preserveLineBreaks = false,
+  } = {},
+) => {
+  const scopedHumanize = (scopedValue, scopedOptions) => {
+    const options = {
+      ...scopedOptions,
+      nestedHumanize: (nestedValue, nestedOptions = {}) => {
+        return scopedHumanize(nestedValue, {
+          ...scopedOptions,
+          depth: scopedOptions.depth + 1,
+          ...nestedOptions,
+        });
+      },
+    };
+    return humanizeValue(scopedValue, options);
+  };
+
+  return scopedHumanize(value, {
+    parenthesis,
+    quote,
+    canUseTemplateString,
+    useNew,
+    objectConstructor,
+    showFunctionBody,
+    indentUsingTab,
+    indentSize,
+    numericSeparator,
+    preserveLineBreaks,
+    depth: 0,
+  });
+};
+
+export const humanizeMethodSymbol = Symbol.for("inspect");
+
+export const humanizeValue = (value, options) => {
+  const customHumanize = value && value[humanizeMethodSymbol];
+  if (customHumanize) {
+    return customHumanize(options);
+  }
+  const primitiveType = primitiveTypeFromValue(value);
+  const primitiveStringifier = primitiveStringifiers[primitiveType];
+  if (primitiveStringifier) {
+    return primitiveStringifier(value, options);
+  }
+  const compositeType = compositeTypeFromObject(value);
+  const compositeStringifier = compositeStringifiers[compositeType];
+  if (compositeStringifier) {
+    return compositeStringifier(value, options);
+  }
+  return inspectConstructor(
+    `${compositeType}(${inspectObject(value, options)})`,
+    {
+      ...options,
+      parenthesis: false,
+    },
+  );
+};
+
+const primitiveTypeFromValue = (value) => {
+  if (value === null) {
+    return "null";
+  }
+  if (value === undefined) {
+    return "undefined";
+  }
+  return typeof value;
+};
+const primitiveStringifiers = {
+  boolean: inspectBoolean,
+  function: inspectFunction,
+  null: inspectNull,
+  number: inspectNumber,
+  string: inspectString,
+  symbol: inspectSymbol,
+  undefined: inspectUndefined,
+  bigint: inspectBigInt,
+};
+const compositeTypeFromObject = (object) => {
+  if (typeof object === "object" && Object.getPrototypeOf(object) === null) {
+    return "Object";
+  }
+  const toStringResult = toString.call(object);
+  // returns format is '[object ${tagName}]';
+  // and we want ${tagName}
+  const tagName = toStringResult.slice("[object ".length, -1);
+  if (tagName === "Object") {
+    const objectConstructorName = object.constructor.name;
+    if (objectConstructorName !== "Object") {
+      return objectConstructorName;
+    }
+  }
+  return tagName;
+};
+const { toString } = Object.prototype;
+
+const compositeStringifiers = {
+  Array: inspectArray,
+  BigInt: inspectBigIntObject,
+  Boolean: inspectBooleanObject,
+  Error: inspectError,
+  Date: inspectDate,
+  Function: inspectFunction,
+  Number: inspectNumberObject,
+  Object: inspectObject,
+  RegExp: inspectRegExp,
+  String: inspectStringObject,
+};

package/src/js_value/null.js

@@ -0,0 +1 @@
+export const inspectNull = () => "null";

package/src/js_value/number.js

@@ -0,0 +1,101 @@
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/rules/numeric-separators-style.js
+
+export const inspectNumber = (value, { numericSeparator }) => {
+  if (isNegativeZero(value)) {
+    return "-0";
+  }
+  // isNaN
+  // eslint-disable-next-line no-self-compare
+  if (value !== value) {
+    return "NaN";
+  }
+  if (value === Infinity) {
+    return "Infinity";
+  }
+  if (value === -Infinity) {
+    return "-Infinity";
+  }
+  const numberString = String(value);
+  if (!numericSeparator) {
+    return numberString;
+  }
+  const {
+    number,
+    mark = "",
+    sign = "",
+    power = "",
+  } = numberString.match(
+    /^(?<number>.*?)(?:(?<mark>e)(?<sign>[+-])?(?<power>\d+))?$/i,
+  ).groups;
+  const numberWithSeparators = formatNumber(number);
+  const powerWithSeparators = addSeparator(power, {
+    minimumDigits: 5,
+    groupLength: 3,
+  });
+  return `${numberWithSeparators}${mark}${sign}${powerWithSeparators}`;
+};
+
+// Use this and instead of Object.is(value, -0)
+// because in some corner cases firefox returns false
+// for Object.is(-0, -0)
+const isNegativeZero = (value) => {
+  return value === 0 && 1 / value === -Infinity;
+};
+
+const formatNumber = (numberString) => {
+  const parts = numberString.split(".");
+  const [integer, fractional] = parts;
+
+  if (parts.length === 2) {
+    const integerWithSeparators = addSeparator(integer, {
+      minimumDigits: 5,
+      groupLength: 3,
+    });
+    return `${integerWithSeparators}.${fractional}`;
+  }
+
+  return addSeparator(integer, {
+    minimumDigits: 5,
+    groupLength: 3,
+  });
+};
+
+const addSeparator = (numberString, { minimumDigits, groupLength }) => {
+  if (numberString[0] === "-") {
+    return `-${groupDigits(numberString.slice(1), {
+      minimumDigits,
+      groupLength,
+    })}`;
+  }
+  return groupDigits(numberString, { minimumDigits, groupLength });
+};
+
+const groupDigits = (digits, { minimumDigits, groupLength }) => {
+  const digitCount = digits.length;
+  if (digitCount < minimumDigits) {
+    return digits;
+  }
+
+  let digitsWithSeparator = digits.slice(-groupLength);
+  let remainingDigits = digits.slice(0, -groupLength);
+  while (remainingDigits.length) {
+    const group = remainingDigits.slice(-groupLength);
+    remainingDigits = remainingDigits.slice(0, -groupLength);
+    digitsWithSeparator = `${group}_${digitsWithSeparator}`;
+  }
+  return digitsWithSeparator;
+};
+
+// const addSeparatorFromLeft = (value, { minimumDigits, groupLength }) => {
+//   const { length } = value;
+//   if (length < minimumDigits) {
+//     return value;
+//   }
+
+//   const parts = [];
+//   for (let start = 0; start < length; start += groupLength) {
+//     const end = Math.min(start + groupLength, length);
+//     parts.push(value.slice(start, end));
+//   }
+//   return parts.join("_");
+// };

package/src/js_value/number_object.js

@@ -0,0 +1,9 @@
+import { inspectConstructor } from "./constructor.js";
+
+export const inspectNumberObject = (
+  value,
+  { nestedHumanize, useNew, parenthesis },
+) => {
+  const numberSource = nestedHumanize(value.valueOf());
+  return inspectConstructor(`Number(${numberSource})`, { useNew, parenthesis });
+};

package/src/js_value/object.js

@@ -0,0 +1,78 @@
+import {
+  preNewLineAndIndentation,
+  wrapNewLineAndIndentation,
+} from "../utils/indentation.js";
+import { inspectConstructor } from "./constructor.js";
+
+export const inspectObject = (
+  value,
+  {
+    nestedHumanize,
+    seen = [],
+    depth,
+    indentUsingTab,
+    indentSize,
+    objectConstructor,
+    parenthesis,
+    useNew,
+  },
+) => {
+  if (seen.indexOf(value) > -1) return "Symbol.for('circular')";
+
+  seen.push(value);
+
+  const propertySourceArray = [];
+  Object.getOwnPropertyNames(value).forEach((propertyName) => {
+    const propertyNameAsNumber = parseInt(propertyName, 10);
+    const propertyNameSource = nestedHumanize(
+      Number.isInteger(propertyNameAsNumber)
+        ? propertyNameAsNumber
+        : propertyName,
+    );
+    propertySourceArray.push({
+      nameOrSymbolSource: propertyNameSource,
+      valueSource: nestedHumanize(value[propertyName], { seen }),
+    });
+  });
+  Object.getOwnPropertySymbols(value).forEach((symbol) => {
+    propertySourceArray.push({
+      nameOrSymbolSource: `[${nestedHumanize(symbol)}]`,
+      valueSource: nestedHumanize(value[symbol], { seen }),
+    });
+  });
+
+  let propertiesSource = "";
+  propertySourceArray.forEach(({ nameOrSymbolSource, valueSource }, index) => {
+    if (index === 0) {
+      propertiesSource += `${nameOrSymbolSource}: ${valueSource}`;
+    } else {
+      propertiesSource += `,${preNewLineAndIndentation(
+        `${nameOrSymbolSource}: ${valueSource}`,
+        {
+          depth,
+          indentUsingTab,
+          indentSize,
+        },
+      )}`;
+    }
+  });
+
+  let objectSource;
+  if (propertiesSource.length) {
+    objectSource = `${wrapNewLineAndIndentation(propertiesSource, {
+      depth,
+      indentUsingTab,
+      indentSize,
+    })}`;
+  } else {
+    objectSource = "";
+  }
+
+  if (objectConstructor) {
+    objectSource = `Object({${objectSource}})`;
+  } else {
+    objectSource = `{${objectSource}}`;
+  }
+
+  return inspectConstructor(objectSource, { parenthesis, useNew });
+};

package/src/js_value/regexp.js

@@ -0,0 +1 @@
+export const inspectRegExp = (value) => value.toString();

package/src/js_value/string.js

@@ -0,0 +1,141 @@
+const DOUBLE_QUOTE = `"`;
+const SINGLE_QUOTE = `'`;
+const BACKTICK = "`";
+
+export const inspectString = (
+  value,
+  {
+    quote = "auto",
+    canUseTemplateString = false,
+    preserveLineBreaks = false,
+    quoteDefault = DOUBLE_QUOTE,
+  } = {},
+) => {
+  quote =
+    quote === "auto"
+      ? determineQuote(value, { canUseTemplateString, quoteDefault })
+      : quote;
+  if (quote === BACKTICK) {
+    return `\`${escapeTemplateStringSpecialCharacters(value)}\``;
+  }
+  return surroundStringWith(value, { quote, preserveLineBreaks });
+};
+
+// https://github.com/mgenware/string-to-template-literal/blob/main/src/main.ts#L1
+const escapeTemplateStringSpecialCharacters = (string) => {
+  string = String(string);
+  let i = 0;
+  let escapedString = "";
+  while (i < string.length) {
+    const char = string[i];
+    i++;
+    escapedString += isTemplateStringSpecialChar(char) ? `\\${char}` : char;
+  }
+  return escapedString;
+};
+
+const isTemplateStringSpecialChar = (char) =>
+  templateStringSpecialChars.indexOf(char) > -1;
+const templateStringSpecialChars = ["\\", "`", "$"];
+
+export const determineQuote = (
+  string,
+  { canUseTemplateString, quoteDefault = DOUBLE_QUOTE } = {},
+) => {
+  const containsDoubleQuote = string.includes(DOUBLE_QUOTE);
+  if (!containsDoubleQuote) {
+    return DOUBLE_QUOTE;
+  }
+  const containsSimpleQuote = string.includes(SINGLE_QUOTE);
+  if (!containsSimpleQuote) {
+    return SINGLE_QUOTE;
+  }
+  if (canUseTemplateString) {
+    const containsBackTick = string.includes(BACKTICK);
+    if (!containsBackTick) {
+      return BACKTICK;
+    }
+  }
+  const doubleQuoteCount = string.split(DOUBLE_QUOTE).length - 1;
+  const singleQuoteCount = string.split(SINGLE_QUOTE).length - 1;
+  if (singleQuoteCount > doubleQuoteCount) {
+    return DOUBLE_QUOTE;
+  }
+  if (doubleQuoteCount > singleQuoteCount) {
+    return SINGLE_QUOTE;
+  }
+  return quoteDefault;
+};
+
+export const inspectChar = (char, { quote, preserveLineBreaks }) => {
+  const point = char.charCodeAt(0);
+  if (preserveLineBreaks && (char === "\n" || char === "\r")) {
+    return char;
+  }
+  if (
+    char === quote ||
+    point === 92 ||
+    point < 32 ||
+    (point > 126 && point < 160) ||
+    // line separators
+    point === 8232 ||
+    point === 8233
+  ) {
+    const replacement =
+      char === quote
+        ? `\\${quote}`
+        : point === 8232
+          ? "\\u2028"
+          : point === 8233
+            ? "\\u2029"
+            : meta[point];
+    return replacement;
+  }
+  return char;
+};
+
+// https://github.com/jsenv/jsenv-uneval/blob/6c97ef9d8f2e9425a66f2c88347e0a118d427f3a/src/internal/escapeString.js#L3
+// https://github.com/jsenv/jsenv-inspect/blob/bb11de3adf262b68f71ed82b0a37d4528dd42229/src/internal/string.js#L3
+// https://github.com/joliss/js-string-escape/blob/master/index.js
+// http://javascript.crockford.com/remedial.html
+const surroundStringWith = (string, { quote, preserveLineBreaks }) => {
+  let result = "";
+  let last = 0;
+  const lastIndex = string.length;
+  let i = 0;
+  while (i < lastIndex) {
+    const char = string[i];
+    const replacement = inspectChar(char, { quote, preserveLineBreaks });
+    if (char !== replacement) {
+      if (last === i) {
+        result += replacement;
+      } else {
+        result += `${string.slice(last, i)}${replacement}`;
+      }
+      last = i + 1;
+    }
+    i++;
+  }
+  if (last !== lastIndex) {
+    result += string.slice(last);
+  }
+  return `${quote}${result}${quote}`;
+};
+
+// prettier-ignore
+const meta = [
+  '\\x00', '\\x01', '\\x02', '\\x03', '\\x04', '\\x05', '\\x06', '\\x07', // x07
+  '\\b', '\\t', '\\n', '\\x0B', '\\f', '\\r', '\\x0E', '\\x0F',           // x0F
+  '\\x10', '\\x11', '\\x12', '\\x13', '\\x14', '\\x15', '\\x16', '\\x17', // x17
+  '\\x18', '\\x19', '\\x1A', '\\x1B', '\\x1C', '\\x1D', '\\x1E', '\\x1F', // x1F
+  '', '', '', '', '', '', '', "\\'", '', '', '', '', '', '', '', '',      // x2F
+  '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',         // x3F
+  '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',         // x4F
+  '', '', '', '', '', '', '', '', '', '', '', '', '\\\\', '', '', '',     // x5F
+  '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',         // x6F
+  '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '\\x7F',    // x7F
+  '\\x80', '\\x81', '\\x82', '\\x83', '\\x84', '\\x85', '\\x86', '\\x87', // x87
+  '\\x88', '\\x89', '\\x8A', '\\x8B', '\\x8C', '\\x8D', '\\x8E', '\\x8F', // x8F
+  '\\x90', '\\x91', '\\x92', '\\x93', '\\x94', '\\x95', '\\x96', '\\x97', // x97
+  '\\x98', '\\x99', '\\x9A', '\\x9B', '\\x9C', '\\x9D', '\\x9E', '\\x9F', // x9F
+];

package/src/js_value/string_object.js

@@ -0,0 +1,10 @@
+import { inspectConstructor } from "./constructor.js";
+
+export const inspectStringObject = (
+  value,
+  { nestedHumanize, useNew, parenthesis },
+) => {
+  const stringSource = nestedHumanize(value.valueOf());
+
+  return inspectConstructor(`String(${stringSource})`, { useNew, parenthesis });
+};

package/src/js_value/symbol.js

@@ -0,0 +1,24 @@
+export const inspectSymbol = (value, { nestedHumanize, parenthesis }) => {
+  const symbolDescription = symbolToDescription(value);
+  const symbolDescriptionSource = symbolDescription
+    ? nestedHumanize(symbolDescription)
+    : "";
+  const symbolSource = `Symbol(${symbolDescriptionSource})`;
+
+  if (parenthesis) return `${symbolSource}`;
+  return symbolSource;
+};
+
+const symbolToDescription =
+  "description" in Symbol.prototype
+    ? (symbol) => symbol.description
+    : (symbol) => {
+        const toStringResult = symbol.toString();
+        const openingParenthesisIndex = toStringResult.indexOf("(");
+        const closingParenthesisIndex = toStringResult.indexOf(")");
+        const symbolDescription = toStringResult.slice(
+          openingParenthesisIndex + 1,
+          closingParenthesisIndex,
+        );
+        return symbolDescription;
+      };

package/src/js_value/undefined.js

@@ -0,0 +1 @@
+export const inspectUndefined = () => "undefined";

package/src/log/LOG_LEVELS.js

@@ -0,0 +1,9 @@
+export const LOG_LEVEL_OFF = "off";
+
+export const LOG_LEVEL_DEBUG = "debug";
+
+export const LOG_LEVEL_INFO = "info";
+
+export const LOG_LEVEL_WARN = "warn";
+
+export const LOG_LEVEL_ERROR = "error";

package/src/log/ansi.js

@@ -0,0 +1,37 @@
+import { createSupportsColor } from "supports-color";
+
+const processSupportsBasicColor = createSupportsColor(process.stdout).hasBasic;
+// 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: processSupportsBasicColor,
+
+  RED: "\x1b[31m",
+  GREEN: "\x1b[32m",
+  YELLOW: "\x1b[33m",
+  BLUE: "\x1b[34m",
+  MAGENTA: "\x1b[35m",
+  GREY: "\x1b[90m",
+  color: (text, ANSI_COLOR) => {
+    return ANSI.supported ? `${ANSI_COLOR}${text}${RESET}` : text;
+  },
+
+  BOLD: "\x1b[1m",
+  effect: (text, ANSI_EFFECT) => {
+    return ANSI.supported ? `${ANSI_EFFECT}${text}${RESET}` : text;
+  },
+};
+
+// GitHub workflow does support ANSI but "supports-color" returns false
+// because stream.isTTY returns false, see https://github.com/actions/runner/issues/241
+if (
+  process.env.GITHUB_WORKFLOW &&
+  // Check on FORCE_COLOR is to ensure it is prio over GitHub workflow check
+  // in unit test we use process.env.FORCE_COLOR = 'false' to fake
+  // that colors are not supported. Let it have priority
+  process.env.FORCE_COLOR !== "false"
+) {
+  ANSI.supported = true;
+}

package/src/log/detailed_message.js

@@ -0,0 +1,17 @@
+export const createDetailedMessage = (message, details = {}) => {
+  let string = `${message}`;
+
+  Object.keys(details).forEach((key) => {
+    const value = details[key];
+    string += `
+--- ${key} ---
+${
+  Array.isArray(value)
+    ? value.join(`
+`)
+    : value
+}`;
+  });
+
+  return string;
+};