prepack/lib/utils.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.typeToString = typeToString;
exports.getTypeFromName = getTypeFromName;
exports.describeValue = describeValue;
exports.jsonToDisplayString = jsonToDisplayString;
exports.verboseToDisplayJson = verboseToDisplayJson;

var _index = require("./values/index.js");

var _invariant = _interopRequireDefault(require("./invariant.js"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * Copyright (c) 2017-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 */

/*  strict-local */
function typeToString(type) {
  function isInstance(proto, Constructor) {
    return proto instanceof Constructor || proto === Constructor.prototype;
  }

  let proto = type.prototype;

  if (isInstance(proto, _index.UndefinedValue)) {
    return "undefined";
  } else if (isInstance(proto, _index.NullValue)) {
    return "object";
  } else if (isInstance(proto, _index.StringValue)) {
    return "string";
  } else if (isInstance(proto, _index.BooleanValue)) {
    return "boolean";
  } else if (isInstance(proto, _index.NumberValue)) {
    return "number";
  } else if (isInstance(proto, _index.SymbolValue)) {
    return "symbol";
  } else if (isInstance(proto, _index.ObjectValue)) {
    if (_index.Value.isTypeCompatibleWith(type, _index.FunctionValue)) {
      return "function";
    }

    return "object";
  } else {
    return undefined;
  }
}

function getTypeFromName(typeName) {
  switch (typeName) {
    case "empty":
      return _index.EmptyValue;

    case "void":
      return _index.UndefinedValue;

    case "null":
      return _index.NullValue;

    case "boolean":
      return _index.BooleanValue;

    case "string":
      return _index.StringValue;

    case "symbol":
      return _index.SymbolValue;

    case "number":
      return _index.NumberValue;

    case "object":
      return _index.ObjectValue;

    case "array":
      return _index.ArrayValue;

    case "function":
      return _index.FunctionValue;

    case "integral":
      return _index.IntegralValue;

    default:
      return undefined;
  }
}

function describeValue(value) {
  let title;
  let suffix = "";
  if (value instanceof _index.PrimitiveValue) title = value.toDisplayString();else if (value instanceof _index.ObjectValue) title = "[object]";else {
    (0, _invariant.default)(value instanceof _index.AbstractValue, value.constructor.name);
    title = "[abstract]";
    if (value.kind !== undefined) title += `, kind: ${value.kind}`;

    for (let arg of value.args) {
      let t = describeValue(arg);
      suffix += t.split("\n").map(u => "  " + u).join("\n") + "\n";
    }
  }
  title += `, hash: ${value.getHash()}`;
  if (value.intrinsicName !== undefined) title += `, intrinsic name: ${value.intrinsicName}`;
  if (value.__originalName !== undefined) title += `, original name: ${value.__originalName}`;
  return suffix ? `${title}\n${suffix}` : title;
}

function jsonToDisplayString(instance, depth) {
  let result = instance.toDisplayJson(depth);
  return typeof result === "string" ? result : JSON.stringify(result, null, 2).replace(/\"/g, "");
}

function verboseToDisplayJson(obj, depth) {
  let result = {};

  function valueOfProp(prop) {
    if (typeof prop === "function") return undefined;

    if (Array.isArray(prop)) {
      // Try to return a 1-line string if possible
      if (prop.length === 0) return "[]";
      let valuesArray = prop.map(x => valueOfProp(x));

      if (valuesArray.length < 5) {
        let string = "[" + valuesArray.reduce((acc, x) => `${acc}, ${x instanceof Object ? JSON.stringify(x) : x}`) + "]";
        string = string.replace(/\"/g, "");
        if (string.length < 60) return string;
      }

      return valuesArray;
    }

    if (prop instanceof Set || prop instanceof Map) return `${prop.constructor.name}(${prop.size})`;
    if (prop.toDisplayJson) return prop.toDisplayJson(depth - 1);
    if (prop.toDisplayString) return prop.toDisplayString();
    if (prop.toJSON) return prop.toJSON();
    return prop.toString();
  }

  for (let key in obj) {
    let prop = obj[key];
    if (!prop) continue;
    let value = valueOfProp(prop);
    if (value && value !== "[object Object]") result[key] = value;
  }

  return result;
}
//# sourceMappingURL=utils.js.map