@jsenv/humanize 1.5.2 → 1.7.0

package/src/ansi/ansi_runtime_agnostic.js

@@ -1,107 +0,0 @@
-// https://github.com/Marak/colors.js/blob/master/lib/styles.js
-// https://stackoverflow.com/a/75985833/2634179
-const RESET = "\x1b[0m";
-
-const RED = "red";
-const GREEN = "green";
-const YELLOW = "yellow";
-const BLUE = "blue";
-const MAGENTA = "magenta";
-const CYAN = "cyan";
-const GREY = "grey";
-const WHITE = "white";
-const BLACK = "black";
-
-const TEXT_COLOR_ANSI_CODES = {
-  [RED]: "\x1b[31m",
-  [GREEN]: "\x1b[32m",
-  [YELLOW]: "\x1b[33m",
-  [BLUE]: "\x1b[34m",
-  [MAGENTA]: "\x1b[35m",
-  [CYAN]: "\x1b[36m",
-  [GREY]: "\x1b[90m",
-  [WHITE]: "\x1b[37m",
-  [BLACK]: "\x1b[30m",
-};
-const BACKGROUND_COLOR_ANSI_CODES = {
-  [RED]: "\x1b[41m",
-  [GREEN]: "\x1b[42m",
-  [YELLOW]: "\x1b[43m",
-  [BLUE]: "\x1b[44m",
-  [MAGENTA]: "\x1b[45m",
-  [CYAN]: "\x1b[46m",
-  [GREY]: "\x1b[100m",
-  [WHITE]: "\x1b[47m",
-  [BLACK]: "\x1b[40m",
-};
-
-export const createAnsi = ({ supported }) => {
-  const ANSI = {
-    supported,
-
-    RED,
-    GREEN,
-    YELLOW,
-    BLUE,
-    MAGENTA,
-    CYAN,
-    GREY,
-    WHITE,
-    BLACK,
-    color: (text, color) => {
-      if (!ANSI.supported) {
-        return text;
-      }
-      if (!color) {
-        return text;
-      }
-      if (typeof text === "string" && text.trim() === "") {
-        // cannot set color of blank chars
-        return text;
-      }
-      const ansiEscapeCodeForTextColor = TEXT_COLOR_ANSI_CODES[color];
-      if (!ansiEscapeCodeForTextColor) {
-        return text;
-      }
-      return `${ansiEscapeCodeForTextColor}${text}${RESET}`;
-    },
-    backgroundColor: (text, color) => {
-      if (!ANSI.supported) {
-        return text;
-      }
-      if (!color) {
-        return text;
-      }
-      if (typeof text === "string" && text.trim() === "") {
-        // cannot set background color of blank chars
-        return text;
-      }
-      const ansiEscapeCodeForBackgroundColor =
-        BACKGROUND_COLOR_ANSI_CODES[color];
-      if (!ansiEscapeCodeForBackgroundColor) {
-        return text;
-      }
-      return `${ansiEscapeCodeForBackgroundColor}${text}${RESET}`;
-    },
-
-    BOLD: "\x1b[1m",
-    UNDERLINE: "\x1b[4m",
-    STRIKE: "\x1b[9m",
-    effect: (text, effect) => {
-      if (!ANSI.supported) {
-        return text;
-      }
-      if (!effect) {
-        return text;
-      }
-      // cannot add effect to empty string
-      if (text === "") {
-        return text;
-      }
-      const ansiEscapeCodeForEffect = effect;
-      return `${ansiEscapeCodeForEffect}${text}${RESET}`;
-    },
-  };
-
-  return ANSI;
-};

package/src/byte/byte.js

@@ -1,44 +0,0 @@
-import { setRoundedPrecision } from "../utils/decimals.js";
-
-export const humanizeFileSize = (numberOfBytes, { decimals, short } = {}) => {
-  return inspectBytes(numberOfBytes, { decimals, short });
-};
-
-export const humanizeMemory = (metricValue, { decimals, short } = {}) => {
-  return inspectBytes(metricValue, { decimals, fixedDecimals: true, short });
-};
-
-const inspectBytes = (
-  number,
-  { fixedDecimals = false, decimals, short } = {},
-) => {
-  if (number === 0) {
-    return `0 B`;
-  }
-  const exponent = Math.min(
-    Math.floor(Math.log10(number) / 3),
-    BYTE_UNITS.length - 1,
-  );
-  const unitNumber = number / Math.pow(1000, exponent);
-  const unitName = BYTE_UNITS[exponent];
-  if (decimals === undefined) {
-    if (unitNumber < 100) {
-      decimals = 1;
-    } else {
-      decimals = 0;
-    }
-  }
-  const unitNumberRounded = setRoundedPrecision(unitNumber, {
-    decimals,
-    decimalsWhenSmall: 1,
-  });
-  const value = fixedDecimals
-    ? unitNumberRounded.toFixed(decimals)
-    : unitNumberRounded;
-  if (short) {
-    return `${value}${unitName}`;
-  }
-  return `${value} ${unitName}`;
-};
-
-const BYTE_UNITS = ["B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];

package/src/content_frame/content_frame.js

@@ -1,157 +0,0 @@
-const formatDefault = (v) => v;
-
-export const generateContentFrame = ({
-  content,
-  line,
-  column,
-
-  linesAbove = 3,
-  linesBelow = 0,
-  lineMaxWidth = 120,
-  lineNumbersOnTheLeft = true,
-  lineMarker = true,
-  columnMarker = true,
-  format = formatDefault,
-} = {}) => {
-  const lineStrings = content.split(/\r?\n/);
-  if (line === 0) line = 1;
-  if (column === undefined) {
-    columnMarker = false;
-    column = 1;
-  }
-  if (column === 0) column = 1;
-
-  let lineStartIndex = line - 1 - linesAbove;
-  if (lineStartIndex < 0) {
-    lineStartIndex = 0;
-  }
-  let lineEndIndex = line - 1 + linesBelow;
-  if (lineEndIndex > lineStrings.length - 1) {
-    lineEndIndex = lineStrings.length - 1;
-  }
-  if (columnMarker) {
-    // human reader deduce the line when there is a column marker
-    lineMarker = false;
-  }
-  if (line - 1 === lineEndIndex) {
-    lineMarker = false; // useless because last line
-  }
-  let lineIndex = lineStartIndex;
-
-  let columnsBefore;
-  let columnsAfter;
-  if (column > lineMaxWidth) {
-    columnsBefore = column - Math.ceil(lineMaxWidth / 2);
-    columnsAfter = column + Math.floor(lineMaxWidth / 2);
-  } else {
-    columnsBefore = 0;
-    columnsAfter = lineMaxWidth;
-  }
-  let columnMarkerIndex = column - 1 - columnsBefore;
-
-  let source = "";
-  while (lineIndex <= lineEndIndex) {
-    const lineString = lineStrings[lineIndex];
-    const lineNumber = lineIndex + 1;
-    const isLastLine = lineIndex === lineEndIndex;
-    const isMainLine = lineNumber === line;
-    lineIndex++;
-
-    write_aside: {
-      if (lineMarker) {
-        if (isMainLine) {
-          source += `${format(">", "marker_line")} `;
-        } else {
-          source += "  ";
-        }
-      }
-      if (lineNumbersOnTheLeft) {
-        // fill with spaces to ensure if line moves from 7,8,9 to 10 the display is still great
-        const asideSource = `${fillLeft(lineNumber, lineEndIndex + 1)} |`;
-        source += `${format(asideSource, "line_number_aside")} `;
-      }
-    }
-    write_line: {
-      source += truncateLine(lineString, {
-        start: columnsBefore,
-        end: columnsAfter,
-        prefix: "…",
-        suffix: "…",
-        format,
-      });
-    }
-    write_column_marker: {
-      if (columnMarker && isMainLine) {
-        source += `\n`;
-        if (lineMarker) {
-          source += "  ";
-        }
-        if (lineNumbersOnTheLeft) {
-          const asideSpaces = `${fillLeft(lineNumber, lineEndIndex + 1)} | `
-            .length;
-          source += " ".repeat(asideSpaces);
-        }
-        source += " ".repeat(columnMarkerIndex);
-        source += format("^", "marker_column");
-      }
-    }
-    if (!isLastLine) {
-      source += "\n";
-    }
-  }
-  return source;
-};
-
-const truncateLine = (line, { start, end, prefix, suffix, format }) => {
-  const lastIndex = line.length;
-
-  if (line.length === 0) {
-    // don't show any ellipsis if the line is empty
-    // because it's not truncated in that case
-    return "";
-  }
-
-  const startTruncated = start > 0;
-  const endTruncated = lastIndex > end;
-
-  let from = startTruncated ? start + prefix.length : start;
-  let to = endTruncated ? end - suffix.length : end;
-  if (to > lastIndex) to = lastIndex;
-
-  if (start >= lastIndex || from === to) {
-    return "";
-  }
-  let result = "";
-  while (from < to) {
-    result += format(line[from], "char");
-    from++;
-  }
-  if (result.length === 0) {
-    return "";
-  }
-  if (startTruncated && endTruncated) {
-    return `${format(prefix, "marker_overflow_left")}${result}${format(
-      suffix,
-      "marker_overflow_right",
-    )}`;
-  }
-  if (startTruncated) {
-    return `${format(prefix, "marker_overflow_left")}${result}`;
-  }
-  if (endTruncated) {
-    return `${result}${format(suffix, "marker_overflow_right")}`;
-  }
-  return result;
-};
-
-const fillLeft = (value, biggestValue, char = " ") => {
-  const width = String(value).length;
-  const biggestWidth = String(biggestValue).length;
-  let missingWidth = biggestWidth - width;
-  let padded = "";
-  while (missingWidth--) {
-    padded += char;
-  }
-  padded += value;
-  return padded;
-};

package/src/error/error_to_html.js

@@ -1,22 +0,0 @@
-export const errorToHTML = (error) => {
-  const errorIsAPrimitive =
-    error === null ||
-    (typeof error !== "object" && typeof error !== "function");
-
-  if (errorIsAPrimitive) {
-    if (typeof error === "string") {
-      return `<pre>${escapeHtml(error)}</pre>`;
-    }
-    return `<pre>${JSON.stringify(error, null, "  ")}</pre>`;
-  }
-  return `<pre>${escapeHtml(error.stack)}</pre>`;
-};
-
-const escapeHtml = (string) => {
-  return string
-    .replace(/&/g, "&amp;")
-    .replace(/</g, "&lt;")
-    .replace(/>/g, "&gt;")
-    .replace(/"/g, "&quot;")
-    .replace(/'/g, "&#039;");
-};

package/src/error/error_to_markdown.js

@@ -1,14 +0,0 @@
-export const errorToMarkdown = (error) => {
-  const errorIsAPrimitive =
-    error === null ||
-    (typeof error !== "object" && typeof error !== "function");
-
-  if (errorIsAPrimitive) {
-    return `\`\`\`js
-${error}
-\`\`\``;
-  }
-  return `\`\`\`
-${error.stack}
-\`\`\``;
-};

package/src/js_value/array.js

@@ -1,58 +0,0 @@
-import {
-  preNewLineAndIndentation,
-  wrapNewLineAndIndentation,
-} from "../utils/indentation.js";
-import { inspectConstructor } from "./constructor.js";
-
-export const inspectArray = (
-  value,
-  {
-    seen = [],
-    nestedHumanize,
-    depth,
-    indentUsingTab,
-    indentSize,
-    parenthesis,
-    useNew,
-  },
-) => {
-  if (seen.indexOf(value) > -1) {
-    return "Symbol.for('circular')";
-  }
-  seen.push(value);
-
-  let valuesSource = "";
-  let i = 0;
-  const j = value.length;
-
-  while (i < j) {
-    const valueSource = value.hasOwnProperty(i)
-      ? nestedHumanize(value[i], { seen })
-      : "";
-    if (i === 0) {
-      valuesSource += valueSource;
-    } else {
-      valuesSource += `,${preNewLineAndIndentation(valueSource, {
-        depth,
-        indentUsingTab,
-        indentSize,
-      })}`;
-    }
-    i++;
-  }
-
-  let arraySource;
-  if (valuesSource.length) {
-    arraySource = wrapNewLineAndIndentation(valuesSource, {
-      depth,
-      indentUsingTab,
-      indentSize,
-    });
-  } else {
-    arraySource = "";
-  }
-
-  arraySource = `[${arraySource}]`;
-
-  return inspectConstructor(arraySource, { parenthesis, useNew });
-};

package/src/js_value/bigint.js

@@ -1,3 +0,0 @@
-export const inspectBigInt = (value) => {
-  return `${value}n`;
-};

package/src/js_value/bigint_object.js

@@ -1,5 +0,0 @@
-export const inspectBigIntObject = (value, { nestedHumanize }) => {
-  const bigIntSource = nestedHumanize(value.valueOf());
-
-  return `BigInt(${bigIntSource})`;
-};

package/src/js_value/boolean.js

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

package/src/js_value/boolean_object.js

@@ -1,12 +0,0 @@
-import { inspectConstructor } from "./constructor.js";
-
-export const inspectBooleanObject = (
-  value,
-  { nestedHumanize, useNew, parenthesis },
-) => {
-  const booleanSource = nestedHumanize(value.valueOf());
-  return inspectConstructor(`Boolean(${booleanSource})`, {
-    useNew,
-    parenthesis,
-  });
-};

package/src/js_value/constructor.js

@@ -1,10 +0,0 @@
-export const inspectConstructor = (value, { parenthesis, useNew }) => {
-  let formattedString = value;
-  if (parenthesis) {
-    formattedString = `(${value})`;
-  }
-  if (useNew) {
-    formattedString = `new ${formattedString}`;
-  }
-  return formattedString;
-};

package/src/js_value/date.js

@@ -1,8 +0,0 @@
-import { inspectConstructor } from "./constructor.js";
-
-export const inspectDate = (value, { nestedHumanize, useNew, parenthesis }) => {
-  const dateSource = nestedHumanize(value.valueOf(), {
-    numericSeparator: false,
-  });
-  return inspectConstructor(`Date(${dateSource})`, { useNew, parenthesis });
-};

package/src/js_value/error.js

@@ -1,34 +0,0 @@
-import { inspectConstructor } from "./constructor.js";
-
-export const inspectError = (
-  error,
-  { nestedHumanize, useNew, parenthesis },
-) => {
-  const messageSource = nestedHumanize(error.message);
-
-  const errorSource = inspectConstructor(
-    `${errorToConstructorName(error)}(${messageSource})`,
-    {
-      useNew,
-      parenthesis,
-    },
-  );
-  return errorSource;
-};
-
-const errorToConstructorName = ({ name }) => {
-  if (derivedErrorNameArray.includes(name)) {
-    return name;
-  }
-  return "Error";
-};
-
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#Error_types
-const derivedErrorNameArray = [
-  "EvalError",
-  "RangeError",
-  "ReferenceError",
-  "SyntaxError",
-  "TypeError",
-  "URIError",
-];

package/src/js_value/function.js

@@ -1,20 +0,0 @@
-export const inspectFunction = (
-  value,
-  { showFunctionBody, parenthesis, depth },
-) => {
-  let functionSource;
-  if (showFunctionBody) {
-    functionSource = value.toString();
-  } else {
-    const isArrowFunction = value.prototype === undefined;
-    const head = isArrowFunction
-      ? "() =>"
-      : `function ${depth === 0 ? value.name : ""}()`;
-    functionSource = `${head} {/* hidden */}`;
-  }
-
-  if (parenthesis) {
-    return `(${functionSource})`;
-  }
-  return functionSource;
-};

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