"use strict";
const estraverse = require('estraverse');
const NodeType_1 = require("./enums/NodeType");
const Nodes_1 = require("./Nodes");
const Utils_1 = require("./Utils");
class NodeUtils {
static addXVerbatimPropertyToLiterals(node) {
estraverse.replace(node, {
enter: (node, parentNode) => {
Eif (Nodes_1.Nodes.isLiteralNode(node)) {
node['x-verbatim-property'] = node.raw;
}
}
});
}
static appendNode(blockScopeBody, node) {
Iif (!NodeUtils.validateNode(node)) {
return;
}
blockScopeBody.push(node);
}
static getBlockStatementNodeByIndex(node, index = 0) {
if (Nodes_1.Nodes.isNodeHasBlockStatement(node)) {
if (node.body[index] === undefined) {
throw new ReferenceError(`Wrong index \`${index}\`. Block-statement body length is \`${node.body.length}\``);
}
return node.body[index];
}
throw new TypeError('The specified node have no a block-statement');
}
static getBlockScopeOfNode(node, depth = 0) {
let parentNode = node.parentNode;
if (!parentNode) {
throw new ReferenceError('`parentNode` property of given node is `undefined`');
}
if (Nodes_1.Nodes.isBlockStatementNode(parentNode)) {
Iif (!Utils_1.Utils.arrayContains(NodeUtils.nodesWithBlockScope, parentNode['parentNode'].type)) {
return NodeUtils.getBlockScopeOfNode(parentNode, depth);
}
else if (depth > 0) {
return NodeUtils.getBlockScopeOfNode(parentNode, --depth);
}
return parentNode;
}
if (Nodes_1.Nodes.isProgramNode(parentNode)) {
return parentNode;
}
return NodeUtils.getBlockScopeOfNode(parentNode);
}
static insertNodeAtIndex(blockScopeBody, node, index) {
Iif (!NodeUtils.validateNode(node)) {
return;
}
blockScopeBody.splice(index, 0, node);
}
static parentize(node) {
let isRootNode = true;
estraverse.replace(node, {
enter: (node, parentNode) => {
Object.defineProperty(node, 'parentNode', {
configurable: true,
enumerable: true,
value: isRootNode ? Nodes_1.Nodes.getProgramNode([node]) : parentNode || node,
writable: true
});
isRootNode = false;
}
});
}
static prependNode(blockScopeBody, node) {
Iif (!NodeUtils.validateNode(node)) {
return;
}
blockScopeBody.unshift(node);
}
static validateNode(node) {
return !!node;
}
}
NodeUtils.nodesWithBlockScope = [
NodeType_1.NodeType.ArrowFunctionExpression,
NodeType_1.NodeType.FunctionDeclaration,
NodeType_1.NodeType.FunctionExpression,
NodeType_1.NodeType.MethodDefinition,
NodeType_1.NodeType.Program
];
exports.NodeUtils = NodeUtils;
//# sourceMappingURL=NodeUtils.js.map |