@ts-nameof/transforms-ts
Version:
ts-nameof - TypeScript compiler transforms for ts-nameof packages.
214 lines • 10.2 kB
JavaScript
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.parse = void 0;
var ts = __importStar(require("typescript"));
var common_1 = require("@ts-nameof/common");
var common = __importStar(require("@ts-nameof/transforms-common"));
var transforms_common_1 = require("@ts-nameof/transforms-common");
var helpers_1 = require("./helpers");
function parse(parsingNode, sourceFile, context) {
if (!isNameof(parsingNode))
return undefined;
var propertyName = parsePropertyName(parsingNode);
if (isInterpolatePropertyName(propertyName)) {
handleNameofInterpolate(parsingNode);
return undefined;
}
return parseNameof(parsingNode);
function parseNameof(callExpr) {
return {
property: propertyName,
typeArguments: parseTypeArguments(callExpr),
arguments: parseArguments(callExpr)
};
}
function parsePropertyName(callExpr) {
var expression = callExpr.expression;
if (!ts.isPropertyAccessExpression(expression) || !ts.isIdentifier(expression.name))
return undefined;
return expression.name.text;
}
function parseTypeArguments(callExpr) {
if (callExpr.typeArguments == null)
return [];
return callExpr.typeArguments.map(function (arg) { return parseCommonNode(arg); });
}
function parseArguments(callExpr) {
return callExpr.arguments.map(function (arg) { return parseCommonNode(arg); });
}
function parseCommonNode(node) {
if (ts.isPropertyAccessExpression(node))
return parsePropertyAccessExpression(node);
if (ts.isElementAccessExpression(node))
return parseElementAccessExpression(node);
if (ts.isArrowFunction(node))
return parseFunctionReturnExpression(node, getArrowFunctionReturnExpression(node));
if (ts.isFunctionExpression(node))
return parseFunctionReturnExpression(node, getReturnStatementExpressionFromBlockOrThrow(node.body));
if (ts.isNonNullExpression(node) || ts.isParenthesizedExpression(node) || ts.isAsExpression(node))
return parseCommonNode(node.expression);
if (ts.isQualifiedName(node))
return parseQualifiedName(node);
if (ts.isTypeReferenceNode(node))
return parseCommonNode(node.typeName);
if (ts.isSpreadElement(node))
return parseCommonNode(node.expression);
if (ts.isNumericLiteral(node) || helpers_1.isNegativeNumericLiteral(node))
return parseNumeric(node);
if (ts.isStringLiteral(node))
return parseStringLiteral(node);
if (ts.isArrayLiteralExpression(node))
return parseArrayLiteralExpression(node);
if (ts.isIdentifier(node))
return parseIdentifier(node);
if (ts.isImportTypeNode(node))
return parseImportType(node);
if (ts.isLiteralTypeNode(node))
return parseCommonNode(node.literal);
if (node.kind === ts.SyntaxKind.ThisKeyword)
return common.createIdentifierNode("this");
if (node.kind === ts.SyntaxKind.SuperKeyword)
return common.createIdentifierNode("super");
if (ts.isNoSubstitutionTemplateLiteral(node))
return common.createTemplateExpressionNode([node.text]);
if (ts.isTemplateExpression(node))
return parseTemplateExpression(node);
if (isNameof(node) && isInterpolatePropertyName(parsePropertyName(node)))
return parseInterpolateNode(node);
return common_1.throwError("Unhandled node kind (" + node.kind + ") in text: " + helpers_1.getNodeText(node, sourceFile)
+ " (Please open an issue if you believe this should be supported.)");
}
function parseArrayLiteralExpression(node) {
var elements = node.elements.map(function (element) { return parseCommonNode(element); });
return common.createArrayLiteralNode(elements);
}
function parsePropertyAccessExpression(node) {
var expressionCommonNode = parseCommonNode(node.expression);
var nameCommonNode = parseIdentifier(node.name);
getEndCommonNode(expressionCommonNode).next = nameCommonNode;
return expressionCommonNode;
}
function parseElementAccessExpression(node) {
var expressionCommonNode = parseCommonNode(node.expression);
var argumentExpressionCommonNode = parseCommonNode(node.argumentExpression);
var computedCommonNode = common.createComputedNode(argumentExpressionCommonNode);
getEndCommonNode(expressionCommonNode).next = computedCommonNode;
return expressionCommonNode;
}
function parseQualifiedName(node) {
var leftCommonNode = parseCommonNode(node.left);
var rightCommonNode = parseCommonNode(node.right);
getEndCommonNode(leftCommonNode).next = rightCommonNode;
return leftCommonNode;
}
function parseNumeric(node) {
return common.createNumericLiteralNode(getNodeValue());
function getNodeValue() {
if (ts.isNumericLiteral(node))
return parseFloat(node.text);
return helpers_1.getNegativeNumericLiteralValue(node);
}
}
function parseStringLiteral(node) {
return common.createStringLiteralNode(node.text);
}
function parseIdentifier(node) {
var text = getIdentifierTextOrThrow(node);
return common.createIdentifierNode(text);
}
function parseFunctionReturnExpression(functionLikeNode, node) {
var parameterNames = functionLikeNode.parameters.map(function (p) {
var name = p.name;
if (ts.isIdentifier(name))
return name.text;
return helpers_1.getNodeText(name, sourceFile);
});
return common.createFunctionNode(parseCommonNode(node), parameterNames);
}
function parseImportType(node) {
var importType = common.createImportTypeNode(node.isTypeOf || false, node.argument && parseCommonNode(node.argument));
var qualifier = node.qualifier && parseCommonNode(node.qualifier);
getEndCommonNode(importType).next = qualifier;
return importType;
}
function parseTemplateExpression(node) {
return common.createTemplateExpressionNode(getParts());
function getParts() {
var parts = [];
if (node.head.text.length > 0)
parts.push(node.head.text);
for (var _i = 0, _a = node.templateSpans; _i < _a.length; _i++) {
var templateSpan = _a[_i];
parts.push(transforms_common_1.createInterpolateNode(templateSpan.expression, helpers_1.getNodeText(templateSpan.expression, sourceFile)));
parts.push(templateSpan.literal.text);
}
return parts;
}
}
function parseInterpolateNode(node) {
if (node.arguments.length !== 1)
return common_1.throwError("Should never happen as this would have been tested for earlier.");
return common.createInterpolateNode(node.arguments[0], helpers_1.getNodeText(node.arguments[0], sourceFile));
}
function getEndCommonNode(commonNode) {
while (commonNode.next != null)
commonNode = commonNode.next;
return commonNode;
}
function getArrowFunctionReturnExpression(func) {
if (ts.isBlock(func.body))
return getReturnStatementExpressionFromBlockOrThrow(func.body);
return func.body;
}
function getIdentifierTextOrThrow(node) {
if (!ts.isIdentifier(node))
return common_1.throwError("Expected node to be an identifier: " + helpers_1.getNodeText(node, sourceFile));
return node.text;
}
function getReturnStatementExpressionFromBlockOrThrow(block) {
return helpers_1.getReturnStatementExpressionFromBlock(block)
|| common_1.throwError("Cound not find return statement with an expression in function expression: " + helpers_1.getNodeText(block, sourceFile));
}
function handleNameofInterpolate(callExpr) {
if (callExpr.arguments.length !== 1)
return common_1.throwError("Unexpected scenario where a nameof.interpolate function did not have a single argument.");
if (context != null)
context.interpolateExpressions.add(callExpr.arguments[0]);
}
function isNameof(node) {
if (!ts.isCallExpression(node))
return false;
var identifier = getIdentifierToInspect(node.expression);
return identifier != null && identifier.text === "nameof";
function getIdentifierToInspect(expression) {
if (ts.isIdentifier(expression))
return expression;
if (ts.isPropertyAccessExpression(expression) && ts.isIdentifier(expression.expression))
return expression.expression;
}
}
function isInterpolatePropertyName(propertyName) {
return propertyName === "interpolate";
}
}
exports.parse = parse;
//# sourceMappingURL=parse.js.map