All files / dist/helpers ast.js

86.42% Statements 70/81
83.82% Branches 57/68
100% Functions 25/25
96.88% Lines 62/64
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153    1x     1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x   1x   1x   1x   1x   1x   1x   1x                           7x       7x 7x 7x               5x 5x 5x       5x         31x       83x       12x 1x 11x 3x 8x 1x 7x 5x 2x 2x           6x                     35x 146x   21x 21x 15x   1x         14x 14x   10x       125x   59x   146x         3x 12x 7x 5x   5x               2x       24x 6x 6x    
'use strict';
 
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.isObjectAssignOrExtendsExpression = isObjectAssignOrExtendsExpression;
exports.isObjectAssignExpression = isObjectAssignExpression;
exports.isExtendsHelperExpression = isExtendsHelperExpression;
exports.isIdentifierNamed = isIdentifierNamed;
exports.isCommentBlock = isCommentBlock;
exports.getIdName = getIdName;
exports.findPropertiesOfNode = findPropertiesOfNode;
exports.getInternalStaticThingsOfClass = getInternalStaticThingsOfClass;
exports.getOtherPropertiesOfIdentifier = getOtherPropertiesOfIdentifier;
exports.getPropertiesOfObjectAssignOrExtendHelper = getPropertiesOfObjectAssignOrExtendHelper;
exports.getPropNames = getPropNames;
exports.groupPropertiesByName = groupPropertiesByName;
 
require('source-map-support/register');
 
var _babelTypes = require('babel-types');
 
var t = _interopRequireWildcard(_babelTypes);
 
var _arrayFlatten = require('array-flatten');
 
var _arrayFlatten2 = _interopRequireDefault(_arrayFlatten);
 
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
function _interopRequireWildcard(obj) { Eif (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
 
// console.log("T:", require('util').inspect(t, { depth: null }));
 
 
// export function isIdentifier(node) {
//   return node && node.type === 'Identifier'
// }
 
// export function isObjectLiteral(node) {
//   return node && node.type === 'ObjectExpression'
// }
 
function isObjectAssignOrExtendsExpression(node) {
  return isObjectAssignExpression(node) || isExtendsHelperExpression(node);
}
 
function isObjectAssignExpression(node) {
  Iif (!t.isCallExpression(node)) return false;
  const callee = node && node.callee;
  return !!(callee.object && callee.property && callee.object.name === 'Object' && callee.property.name === 'assign');
}
 
// export function isCallExpression(node) {
//   return node && node.type === 'CallExpression'
// }
 
function isExtendsHelperExpression(node) {
  Iif (!t.isCallExpression(node)) return false;
  const callee = node && node.callee;
  return isIdentifierNamed(callee, '_extends');
}
 
function isIdentifierNamed(node, name) {
  return t.isIdentifier(node, { name: name });
}
 
// This doesn't exist on babel-types
function isCommentBlock(node) {
  return node && node.type === 'CommentBlock';
}
 
function getIdName(node) {
  return node.id && node.id.name;
}
 
function findPropertiesOfNode(blockScopeNode, declaration) {
  if (t.isFunctionDeclaration(declaration) || t.isArrowFunctionExpression(declaration)) {
    return null;
  } else if (t.isObjectExpression(declaration)) {
    return declaration.properties;
  } else if (t.isClass(declaration)) {
    return [...getInternalStaticThingsOfClass(declaration), ...getOtherPropertiesOfIdentifier(blockScopeNode, declaration.id.name)];
  } else if (t.isIdentifier(declaration)) {
    return getOtherPropertiesOfIdentifier(blockScopeNode, declaration.name);
  } else Eif (isObjectAssignOrExtendsExpression(declaration)) {
    return getPropertiesOfObjectAssignOrExtendHelper(declaration, blockScopeNode);
  }
  return null;
}
 
function getInternalStaticThingsOfClass(classNode) {
  return classNode.body.body.filter(item => item.static);
}
 
/**
 * Traverse the top-level of the scope (program or function body) looking for either:
 *  - ObjectExpression assignments to the object variable.
 *  - Property assignments directly to our object (but not to nested properties).
 *
 *  @return Array<{key, value}>
 */
function getOtherPropertiesOfIdentifier(blockScopeNode, idName) {
  return (0, _arrayFlatten2.default)(blockScopeNode.body.map(node => {
    if (t.isExpressionStatement(node)) {
      // ID = value | ID.key = value | ID.key.nested = value
      const { left, right } = node.expression;
      if (t.isAssignmentExpression(node.expression)) {
        if (t.isIdentifier(left) && left.name === idName) {
          // ID = value
          Iif (t.isObjectExpression(right)) {
            // ID = {}
            return right.properties; // Array<ObjectProperty>
          }
        } else {
          const { object, property: key } = left;
          if (t.isIdentifier(object) && object.name === idName) {
            // ID.key = value
            return { key, value: right }; // ObjectProperty-like (key, value)
          }
        }
      }
    } else if (t.isVariableDeclaration(node)) {
      // console.log(require('util').inspect(node, { depth: 4 }));
      return node.declarations.filter(declaration => declaration.id.name === idName).map(declaration => declaration.init).filter(init => init).filter(init => t.isObjectExpression(init) || isObjectAssignOrExtendsExpression(init)).map(init => t.isObjectExpression(init) ? init.properties : getPropertiesOfObjectAssignOrExtendHelper(init, blockScopeNode));
    }
  }).filter(item => item));
}
 
function getPropertiesOfObjectAssignOrExtendHelper(node, blockScopeNode) {
  // Object.assign(...). Check all the args and recursively try to get props of identifiers (although they may be imported)
  return (0, _arrayFlatten2.default)(node.arguments.map(arg => {
    if (t.isObjectExpression(arg)) {
      return arg.properties;
    } else Eif (t.isIdentifier(arg)) {
      // recurse. although props will be empty if arg is an imported object
      return getOtherPropertiesOfIdentifier(blockScopeNode, arg.name);
    }
  }));
}
 
// function getPropsFromObjectAssign()
 
function getPropNames(props) {
  return props.map(prop => prop.key.name);
}
 
function groupPropertiesByName(properties) {
  return properties && properties.reduce((accumulator, property) => {
    accumulator[property.key.name] = property.value;
    return accumulator;
  }, {});
}