@jsenv/humanize 1.6.0 → 1.7.0

package/src/js_value/humanize.js

@@ -1,142 +0,0 @@
-// tslint:disable:ordered-imports
-
-// 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");
-
-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

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

package/src/js_value/number.js

@@ -1,101 +0,0 @@
-// 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

@@ -1,9 +0,0 @@
-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

@@ -1,78 +0,0 @@
-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

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

package/src/js_value/string.js

@@ -1,141 +0,0 @@
-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;
-};
-
-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

@@ -1,10 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

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

package/src/log/LOG_LEVELS.js

@@ -1,9 +0,0 @@
-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/call_orderer.js

@@ -1,39 +0,0 @@
-export const createCallOrderer = () => {
-  const queue = [];
-  const callWhenPreviousExecutionAreDone = (executionIndex, callback) => {
-    if (queue[executionIndex]) {
-      throw new Error(`${executionIndex} already used`);
-    }
-
-    let allBeforeAreDone = true;
-    if (executionIndex > 0) {
-      let beforeIndex = executionIndex - 1;
-      do {
-        const value = queue[beforeIndex];
-        if (!value) {
-          allBeforeAreDone = false;
-          break;
-        }
-      } while (beforeIndex--);
-    }
-    if (!allBeforeAreDone) {
-      queue[executionIndex] = callback;
-      return;
-    }
-    queue[executionIndex] = true;
-    callback();
-    let afterIndex = executionIndex + 1;
-    while (afterIndex < queue.length) {
-      const value = queue[afterIndex];
-      if (value === undefined) {
-        break;
-      }
-      if (typeof value === "function") {
-        queue[afterIndex] = true;
-        value();
-      }
-      afterIndex++;
-    }
-  };
-  return callWhenPreviousExecutionAreDone;
-};

package/src/log/detailed_message.js

@@ -1,29 +0,0 @@
-export const createDetailedMessage = (message, details = {}) => {
-  let text = `${message}`;
-  const namedSectionsText = renderNamedSections(details);
-  if (namedSectionsText) {
-    text += `
-${namedSectionsText}`;
-  }
-  return text;
-};
-
-export const renderNamedSections = (namedSections) => {
-  let text = "";
-  let keys = Object.keys(namedSections);
-  for (const key of keys) {
-    const isLastKey = key === keys[keys.length - 1];
-    const value = namedSections[key];
-    text += `--- ${key} ---
-${
-  Array.isArray(value)
-    ? value.join(`
-`)
-    : value
-}`;
-    if (!isLastKey) {
-      text += "\n";
-    }
-  }
-  return text;
-};

package/src/log/details.js

@@ -1,26 +0,0 @@
-import { ANSI } from "../ansi/ansi_node.js";
-
-export const renderDetails = (data) => {
-  const details = [];
-  for (const key of Object.keys(data)) {
-    const value = data[key];
-    let valueString = "";
-    valueString += ANSI.color(`${key}:`, ANSI.GREY);
-    const useNonGreyAnsiColor =
-      typeof value === "string" && value.includes("\x1b");
-    valueString += " ";
-    valueString += useNonGreyAnsiColor
-      ? value
-      : ANSI.color(String(value), ANSI.GREY);
-    details.push(valueString);
-  }
-  if (details.length === 0) {
-    return "";
-  }
-
-  let string = "";
-  string += ` ${ANSI.color("(", ANSI.GREY)}`;
-  string += details.join(ANSI.color(", ", ANSI.GREY));
-  string += ANSI.color(")", ANSI.GREY);
-  return string;
-};