denoland-deno/testing/format.ts

// This file is ported from pretty-format@24.0.0
/**
 * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 */
export type Refs = any[];
export type Optional<T> = { [K in keyof T]?: T[K] };

export interface Options {
  callToJSON: boolean;
  escapeRegex: boolean;
  escapeString: boolean;
  indent: number;
  maxDepth: number;
  min: boolean;
  printFunctionName: boolean;
}

export interface Config {
  callToJSON: boolean;
  escapeRegex: boolean;
  escapeString: boolean;
  indent: string;
  maxDepth: number;
  min: boolean;
  printFunctionName: boolean;
  spacingInner: string;
  spacingOuter: string;
}

export type Printer = (
  val: any,
  config: Config,
  indentation: string,
  depth: number,
  refs: Refs,
  hasCalledToJSON?: boolean
) => string;

const toString = Object.prototype.toString;
const toISOString = Date.prototype.toISOString;
const errorToString = Error.prototype.toString;
const regExpToString = RegExp.prototype.toString;
const symbolToString = Symbol.prototype.toString;

const DEFAULT_OPTIONS: Options = {
  callToJSON: true,
  escapeRegex: false,
  escapeString: true,
  indent: 2,
  maxDepth: Infinity,
  min: false,
  printFunctionName: true
};

interface BasicValueOptions {
  printFunctionName: boolean;
  escapeRegex: boolean;
  escapeString: boolean;
}

/**
 * Explicitly comparing typeof constructor to function avoids undefined as name
 * when mock identity-obj-proxy returns the key as the value for any key.
 */
const getConstructorName = (val: new (...args: any[]) => any) =>
  (typeof val.constructor === "function" && val.constructor.name) || "Object";

/* global window */
/** Is val is equal to global window object? Works even if it does not exist :) */
const isWindow = (val: any) => typeof window !== "undefined" && val === window;

const SYMBOL_REGEXP = /^Symbol\((.*)\)(.*)$/;

function isToStringedArrayType(toStringed: string): boolean {
  return (
    toStringed === "[object Array]" ||
    toStringed === "[object ArrayBuffer]" ||
    toStringed === "[object DataView]" ||
    toStringed === "[object Float32Array]" ||
    toStringed === "[object Float64Array]" ||
    toStringed === "[object Int8Array]" ||
    toStringed === "[object Int16Array]" ||
    toStringed === "[object Int32Array]" ||
    toStringed === "[object Uint8Array]" ||
    toStringed === "[object Uint8ClampedArray]" ||
    toStringed === "[object Uint16Array]" ||
    toStringed === "[object Uint32Array]"
  );
}

function printNumber(val: number): string {
  return Object.is(val, -0) ? "-0" : String(val);
}

function printFunction(val: () => void, printFunctionName: boolean): string {
  if (!printFunctionName) {
    return "[Function]";
  }
  return "[Function " + (val.name || "anonymous") + "]";
}

function printSymbol(val: symbol): string {
  return symbolToString.call(val).replace(SYMBOL_REGEXP, "Symbol($1)");
}

function printError(val: Error): string {
  return "[" + errorToString.call(val) + "]";
}

/**
 * The first port of call for printing an object, handles most of the
 * data-types in JS.
 */
function printBasicValue(
  val: any,
  { printFunctionName, escapeRegex, escapeString }: BasicValueOptions
): string | null {
  if (val === true || val === false) {
    return "" + val;
  }
  if (val === undefined) {
    return "undefined";
  }
  if (val === null) {
    return "null";
  }

  const typeOf = typeof val;

  if (typeOf === "number") {
    return printNumber(val);
  }
  if (typeOf === "string") {
    if (escapeString) {
      return '"' + val.replace(/"|\\/g, "\\$&") + '"';
    }
    return '"' + val + '"';
  }
  if (typeOf === "function") {
    return printFunction(val, printFunctionName);
  }
  if (typeOf === "symbol") {
    return printSymbol(val);
  }

  const toStringed = toString.call(val);

  if (toStringed === "[object WeakMap]") {
    return "WeakMap {}";
  }
  if (toStringed === "[object WeakSet]") {
    return "WeakSet {}";
  }
  if (
    toStringed === "[object Function]" ||
    toStringed === "[object GeneratorFunction]"
  ) {
    return printFunction(val, printFunctionName);
  }
  if (toStringed === "[object Symbol]") {
    return printSymbol(val);
  }
  if (toStringed === "[object Date]") {
    return isNaN(+val) ? "Date { NaN }" : toISOString.call(val);
  }
  if (toStringed === "[object Error]") {
    return printError(val);
  }
  if (toStringed === "[object RegExp]") {
    if (escapeRegex) {
      // https://github.com/benjamingr/RegExp.escape/blob/master/polyfill.js
      return regExpToString.call(val).replace(/[\\^$*+?.()|[\]{}]/g, "\\$&");
    }
    return regExpToString.call(val);
  }

  if (val instanceof Error) {
    return printError(val);
  }

  return null;
}

/**
 * Handles more complex objects ( such as objects with circular references.
 * maps and sets etc )
 */
function printComplexValue(
  val: any,
  config: Config,
  indentation: string,
  depth: number,
  refs: Refs,
  hasCalledToJSON?: boolean
): string {
  if (refs.indexOf(val) !== -1) {
    return "[Circular]";
  }
  refs = refs.slice();
  refs.push(val);

  const hitMaxDepth = ++depth > config.maxDepth;
  const { min, callToJSON } = config;

  if (
    callToJSON &&
    !hitMaxDepth &&
    val.toJSON &&
    typeof val.toJSON === "function" &&
    !hasCalledToJSON
  ) {
    return printer(val.toJSON(), config, indentation, depth, refs, true);
  }

  const toStringed = toString.call(val);
  if (toStringed === "[object Arguments]") {
    return hitMaxDepth
      ? "[Arguments]"
      : (min ? "" : "Arguments ") +
          "[" +
          printListItems(val, config, indentation, depth, refs, printer) +
          "]";
  }
  if (isToStringedArrayType(toStringed)) {
    return hitMaxDepth
      ? "[" + val.constructor.name + "]"
      : (min ? "" : val.constructor.name + " ") +
          "[" +
          printListItems(val, config, indentation, depth, refs, printer) +
          "]";
  }
  if (toStringed === "[object Map]") {
    return hitMaxDepth
      ? "[Map]"
      : "Map {" +
          printIteratorEntries(
            val.entries(),
            config,
            indentation,
            depth,
            refs,
            printer,
            " => "
          ) +
          "}";
  }
  if (toStringed === "[object Set]") {
    return hitMaxDepth
      ? "[Set]"
      : "Set {" +
          printIteratorValues(
            val.values(),
            config,
            indentation,
            depth,
            refs,
            printer
          ) +
          "}";
  }

  // Avoid failure to serialize global window object in jsdom test environment.
  // For example, not even relevant if window is prop of React element.
  return hitMaxDepth || isWindow(val)
    ? "[" + getConstructorName(val) + "]"
    : (min ? "" : getConstructorName(val) + " ") +
        "{" +
        printObjectProperties(val, config, indentation, depth, refs, printer) +
        "}";
}

function printer(
  val: any,
  config: Config,
  indentation: string,
  depth: number,
  refs: Refs,
  hasCalledToJSON?: boolean
): string {
  const basicResult = printBasicValue(val, config);
  if (basicResult !== null) {
    return basicResult;
  }
  return printComplexValue(
    val,
    config,
    indentation,
    depth,
    refs,
    hasCalledToJSON
  );
}

const getConfig = (options: Options): Config => ({
  ...options,
  indent: options.min ? "" : createIndent(options.indent),
  spacingInner: options.min ? " " : "\n",
  spacingOuter: options.min ? "" : "\n"
});

function createIndent(indent: number): string {
  return new Array(indent + 1).join(" ");
}

const getKeysOfEnumerableProperties = (object: {}) => {
  const keys: Array<string | symbol> = Object.keys(object).sort();

  if (Object.getOwnPropertySymbols) {
    Object.getOwnPropertySymbols(object).forEach(symbol => {
      if (Object.getOwnPropertyDescriptor(object, symbol)!.enumerable) {
        keys.push(symbol);
      }
    });
  }

  return keys;
};

/**
 * Return entries (for example, of a map)
 * with spacing, indentation, and comma
 * without surrounding punctuation (for example, braces)
 */
function printIteratorEntries(
  iterator: any,
  config: Config,
  indentation: string,
  depth: number,
  refs: Refs,
  printer: Printer,
  // Too bad, so sad that separator for ECMAScript Map has been ' => '
  // What a distracting diff if you change a data structure to/from
  // ECMAScript Object or Immutable.Map/OrderedMap which use the default.
  separator: string = ": "
): string {
  let result = "";
  let current = iterator.next();

  if (!current.done) {
    result += config.spacingOuter;

    const indentationNext = indentation + config.indent;

    while (!current.done) {
      const name = printer(
        current.value[0],
        config,
        indentationNext,
        depth,
        refs
      );
      const value = printer(
        current.value[1],
        config,
        indentationNext,
        depth,
        refs
      );

      result += indentationNext + name + separator + value;

      current = iterator.next();

      if (!current.done) {
        result += "," + config.spacingInner;
      } else if (!config.min) {
        result += ",";
      }
    }

    result += config.spacingOuter + indentation;
  }

  return result;
}

/**
 * Return values (for example, of a set)
 * with spacing, indentation, and comma
 * without surrounding punctuation (braces or brackets)
 */
function printIteratorValues(
  iterator: Iterator<any>,
  config: Config,
  indentation: string,
  depth: number,
  refs: Refs,
  printer: Printer
): string {
  let result = "";
  let current = iterator.next();

  if (!current.done) {
    result += config.spacingOuter;

    const indentationNext = indentation + config.indent;

    while (!current.done) {
      result +=
        indentationNext +
        printer(current.value, config, indentationNext, depth, refs);

      current = iterator.next();

      if (!current.done) {
        result += "," + config.spacingInner;
      } else if (!config.min) {
        result += ",";
      }
    }

    result += config.spacingOuter + indentation;
  }

  return result;
}

/**
 * Return items (for example, of an array)
 * with spacing, indentation, and comma
 * without surrounding punctuation (for example, brackets)
 */
function printListItems(
  list: any,
  config: Config,
  indentation: string,
  depth: number,
  refs: Refs,
  printer: Printer
): string {
  let result = "";

  if (list.length) {
    result += config.spacingOuter;

    const indentationNext = indentation + config.indent;

    for (let i = 0; i < list.length; i++) {
      result +=
        indentationNext +
        printer(list[i], config, indentationNext, depth, refs);

      if (i < list.length - 1) {
        result += "," + config.spacingInner;
      } else if (!config.min) {
        result += ",";
      }
    }

    result += config.spacingOuter + indentation;
  }

  return result;
}

/**
 * Return properties of an object
 * with spacing, indentation, and comma
 * without surrounding punctuation (for example, braces)
 */
function printObjectProperties(
  val: {},
  config: Config,
  indentation: string,
  depth: number,
  refs: Refs,
  printer: Printer
): string {
  let result = "";
  const keys = getKeysOfEnumerableProperties(val);

  if (keys.length) {
    result += config.spacingOuter;

    const indentationNext = indentation + config.indent;

    for (let i = 0; i < keys.length; i++) {
      const key = keys[i];
      const name = printer(key, config, indentationNext, depth, refs);
      const value = printer(
        val[key as keyof typeof val],
        config,
        indentationNext,
        depth,
        refs
      );

      result += indentationNext + name + ": " + value;

      if (i < keys.length - 1) {
        result += "," + config.spacingInner;
      } else if (!config.min) {
        result += ",";
      }
    }

    result += config.spacingOuter + indentation;
  }

  return result;
}

/**
 * Returns a presentation string of your `val` object
 * @param val any potential JavaScript object
 * @param options Custom settings
 */
export function format(val: any, options: Optional<Options> = {}): string {
  const opts = Object.keys(DEFAULT_OPTIONS).reduce(
    (acc: Options, k: keyof Options) => {
      const opt = options[k];
      if (typeof opt === "undefined") {
        return { ...acc, [k]: DEFAULT_OPTIONS[k] };
      }
      return { ...acc, [k]: opt };
    },
    {}
  ) as Options;
  const basicResult = printBasicValue(val, opts);
  if (basicResult !== null) {
    return basicResult;
  }

  return printComplexValue(val, getConfig(opts), "", 0, []);
}