108 lines
2.3 KiB
JavaScript
108 lines
2.3 KiB
JavaScript
/* @noflow */
|
|
|
|
import whitespace from "./whitespace";
|
|
import * as parens from "./parentheses";
|
|
import each from "lodash/collection/each";
|
|
import * as t from "babel-types";
|
|
|
|
function find(obj, node, parent) {
|
|
if (!obj) return;
|
|
let result;
|
|
|
|
let types = Object.keys(obj);
|
|
for (let i = 0; i < types.length; i++) {
|
|
let type = types[i];
|
|
|
|
if (t.is(type, node)) {
|
|
let fn = obj[type];
|
|
result = fn(node, parent);
|
|
if (result != null) break;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
function isOrHasCallExpression(node) {
|
|
if (t.isCallExpression(node)) {
|
|
return true;
|
|
}
|
|
|
|
if (t.isMemberExpression(node)) {
|
|
return isOrHasCallExpression(node.object) ||
|
|
(!node.computed && isOrHasCallExpression(node.property));
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
export default class Node {
|
|
constructor(node: Object, parent: Object) {
|
|
this.parent = parent;
|
|
this.node = node;
|
|
}
|
|
|
|
parent: Object;
|
|
node: Object;
|
|
|
|
static isUserWhitespacable(node) {
|
|
return t.isUserWhitespacable(node);
|
|
}
|
|
|
|
static needsWhitespace(node, parent, type) {
|
|
if (!node) return 0;
|
|
|
|
if (t.isExpressionStatement(node)) {
|
|
node = node.expression;
|
|
}
|
|
|
|
let linesInfo = find(whitespace.nodes, node, parent);
|
|
|
|
if (!linesInfo) {
|
|
let items = find(whitespace.list, node, parent);
|
|
if (items) {
|
|
for (let i = 0; i < items.length; i++) {
|
|
linesInfo = Node.needsWhitespace(items[i], node, type);
|
|
if (linesInfo) break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (linesInfo && linesInfo[type]) || 0;
|
|
}
|
|
|
|
static needsWhitespaceBefore(node, parent) {
|
|
return Node.needsWhitespace(node, parent, "before");
|
|
}
|
|
|
|
static needsWhitespaceAfter(node, parent) {
|
|
return Node.needsWhitespace(node, parent, "after");
|
|
}
|
|
|
|
static needsParens(node, parent) {
|
|
if (!parent) return false;
|
|
|
|
if (t.isNewExpression(parent) && parent.callee === node) {
|
|
if (isOrHasCallExpression(node)) return true;
|
|
}
|
|
|
|
return find(parens, node, parent);
|
|
}
|
|
}
|
|
|
|
each(Node, function (fn, key) {
|
|
Node.prototype[key] = function () {
|
|
// Avoid leaking arguments to prevent deoptimization
|
|
let args = new Array(arguments.length + 2);
|
|
|
|
args[0] = this.node;
|
|
args[1] = this.parent;
|
|
|
|
for (let i = 0; i < args.length; i++) {
|
|
args[i + 2] = arguments[i];
|
|
}
|
|
|
|
return Node[key].apply(null, args);
|
|
};
|
|
});
|