const compilerOptions = context.getCompilerOptions();

let currentSourceFile: SourceFile;

return chainBundle(transformSourceFile);

/**

* Transform JSX-specific syntax in a SourceFile.

*

* @param node A SourceFile node.

*/

function transformSourceFile(node: SourceFile) {

if (node.isDeclarationFile) {

return node;

}

currentSourceFile = node;

const visited = visitEachChild(node, visitor, context);

addEmitHelpers(visited, context.readEmitHelpers());

return visited;

}

function visitor(node: Node): VisitResult<Node> {

if (node.transformFlags & TransformFlags.ContainsJsx) {

return visitorWorker(node);

}

else {

return node;

}

}

function visitorWorker(node: Node): VisitResult<Node> {

switch (node.kind) {

case SyntaxKind.JsxElement:

return visitJsxElement(<JsxElement>node, /*isChild*/ false);

case SyntaxKind.JsxSelfClosingElement:

return visitJsxSelfClosingElement(<JsxSelfClosingElement>node, /*isChild*/ false);

case SyntaxKind.JsxFragment:

return visitJsxFragment(<JsxFragment>node, /*isChild*/ false);

case SyntaxKind.JsxExpression:

return visitJsxExpression(<JsxExpression>node);

default:

return visitEachChild(node, visitor, context);

}

}

function transformJsxChildToExpression(node: JsxChild): Expression {

switch (node.kind) {

case SyntaxKind.JsxText:

return visitJsxText(node);

case SyntaxKind.JsxExpression:

return visitJsxExpression(node);

case SyntaxKind.JsxElement:

return visitJsxElement(node, /*isChild*/ true);

case SyntaxKind.JsxSelfClosingElement:

return visitJsxSelfClosingElement(node, /*isChild*/ true);

case SyntaxKind.JsxFragment:

return visitJsxFragment(node, /*isChild*/ true);

default:

return Debug.failBadSyntaxKind(node);

}

}

function visitJsxElement(node: JsxElement, isChild: boolean) {

return visitJsxOpeningLikeElement(node.openingElement, node.children, isChild, /*location*/ node);

}

function visitJsxSelfClosingElement(node: JsxSelfClosingElement, isChild: boolean) {

return visitJsxOpeningLikeElement(node, /*children*/ undefined, isChild, /*location*/ node);

}

function visitJsxFragment(node: JsxFragment, isChild: boolean) {

return visitJsxOpeningFragment(node.openingFragment, node.children, isChild, /*location*/ node);

}

function visitJsxOpeningLikeElement(node: JsxOpeningLikeElement, children: ReadonlyArray<JsxChild>, isChild: boolean, location: TextRange) {

const tagName = getTagName(node);

let objectProperties: Expression;

const attrs = node.attributes.properties;

if (attrs.length === 0) {

// When there are no attributes, React wants "null"

objectProperties = createNull();

}

else {

// Map spans of JsxAttribute nodes into object literals and spans

// of JsxSpreadAttribute nodes into expressions.

const segments = flatten<Expression | ObjectLiteralExpression>(

spanMap(attrs, isJsxSpreadAttribute, (attrs, isSpread) => isSpread

? map(attrs, transformJsxSpreadAttributeToExpression)

: createObjectLiteral(map(attrs, transformJsxAttributeToObjectLiteralElement))

)

);

if (isJsxSpreadAttribute(attrs[0])) {

// We must always emit at least one object literal before a spread

// argument.

segments.unshift(createObjectLiteral());

}

// Either emit one big object literal (no spread attribs), or

// a call to the __assign helper.

objectProperties = singleOrUndefined(segments);

if (!objectProperties) {

objectProperties = createAssignHelper(context, segments);

}

}

const element = createExpressionForJsxElement(

context.getEmitResolver().getJsxFactoryEntity(currentSourceFile),

compilerOptions.reactNamespace,

tagName,

objectProperties,

mapDefined(children, transformJsxChildToExpression),

node,

location

);

if (isChild) {

startOnNewLine(element);

}

return element;

}

function visitJsxOpeningFragment(node: JsxOpeningFragment, children: ReadonlyArray<JsxChild>, isChild: boolean, location: TextRange) {

const element = createExpressionForJsxFragment(

context.getEmitResolver().getJsxFactoryEntity(currentSourceFile),

compilerOptions.reactNamespace,

mapDefined(children, transformJsxChildToExpression),

node,

location

);

if (isChild) {

startOnNewLine(element);

}

return element;

}

function transformJsxSpreadAttributeToExpression(node: JsxSpreadAttribute) {

return visitNode(node.expression, visitor, isExpression);

}

function transformJsxAttributeToObjectLiteralElement(node: JsxAttribute) {

const name = getAttributeName(node);

const expression = transformJsxAttributeInitializer(node.initializer);

return createPropertyAssignment(name, expression);

}

function transformJsxAttributeInitializer(node: StringLiteral | JsxExpression) {

if (node === undefined) {

return createTrue();

}

else if (node.kind === SyntaxKind.StringLiteral) {

// Always recreate the literal to escape any escape sequences or newlines which may be in the original jsx string and which

// Need to be escaped to be handled correctly in a normal string

const literal = createLiteral(tryDecodeEntities(node.text) || node.text);

literal.singleQuote = node.singleQuote !== undefined ? node.singleQuote : !isStringDoubleQuoted(node, currentSourceFile);

return setTextRange(literal, node);

}

else if (node.kind === SyntaxKind.JsxExpression) {

if (node.expression === undefined) {

return createTrue();

}

return visitJsxExpression(node);

}

else {

return Debug.failBadSyntaxKind(node);

}

}

function visitJsxText(node: JsxText): StringLiteral | undefined {

const fixed = fixupWhitespaceAndDecodeEntities(getTextOfNode(node, /*includeTrivia*/ true));

return fixed === undefined ? undefined : createLiteral(fixed);

}

/**

* JSX trims whitespace at the end and beginning of lines, except that the

* start/end of a tag is considered a start/end of a line only if that line is

* on the same line as the closing tag. See examples in

* tests/cases/conformance/jsx/tsxReactEmitWhitespace.tsx

* See also https://www.w3.org/TR/html4/struct/text.html#h-9.1 and https://www.w3.org/TR/CSS2/text.html#white-space-model

*

* An equivalent algorithm would be:

* - If there is only one line, return it.

* - If there is only whitespace (but multiple lines), return `undefined`.

* - Split the text into lines.

* - 'trimRight' the first line, 'trimLeft' the last line, 'trim' middle lines.

* - Decode entities on each line (individually).

* - Remove empty lines and join the rest with " ".

*/

function fixupWhitespaceAndDecodeEntities(text: string): string | undefined {

let acc: string | undefined;

// First non-whitespace character on this line.

let firstNonWhitespace = 0;

// Last non-whitespace character on this line.

let lastNonWhitespace = -1;

// These initial values are special because the first line is:

// firstNonWhitespace = 0 to indicate that we want leading whitsepace,

// but lastNonWhitespace = -1 as a special flag to indicate that we *don't* include the line if it's all whitespace.

for (let i = 0; i < text.length; i++) {

const c = text.charCodeAt(i);

if (isLineBreak(c)) {

// If we've seen any non-whitespace characters on this line, add the 'trim' of the line.

// (lastNonWhitespace === -1 is a special flag to detect whether the first line is all whitespace.)

if (firstNonWhitespace !== -1 && lastNonWhitespace !== -1) {

acc = addLineOfJsxText(acc, text.substr(firstNonWhitespace, lastNonWhitespace - firstNonWhitespace + 1));

}

// Reset firstNonWhitespace for the next line.

// Don't bother to reset lastNonWhitespace because we ignore it if firstNonWhitespace = -1.

firstNonWhitespace = -1;

}

else if (!isWhiteSpaceSingleLine(c)) {

lastNonWhitespace = i;

if (firstNonWhitespace === -1) {

firstNonWhitespace = i;

}

}

}

return firstNonWhitespace !== -1

// Last line had a non-whitespace character. Emit the 'trimLeft', meaning keep trailing whitespace.

? addLineOfJsxText(acc, text.substr(firstNonWhitespace))

// Last line was all whitespace, so ignore it

: acc;

}

function addLineOfJsxText(acc: string | undefined, trimmedLine: string): string {

// We do not escape the string here as that is handled by the printer

// when it emits the literal. We do, however, need to decode JSX entities.

const decoded = decodeEntities(trimmedLine);

return acc === undefined ? decoded : acc + " " + decoded;

}

/**

* Replace entities like "&nbsp;", "&#123;", and "&#xDEADBEEF;" with the characters they encode.

* See https://en.wikipedia.org/wiki/List_of_XML_and_HTML_character_entity_references

*/

function decodeEntities(text: string): string {

return text.replace(/&((#((\d+)|x([\da-fA-F]+)))|(\w+));/g, (match, _all, _number, _digits, decimal, hex, word) => {

if (decimal) {

return String.fromCharCode(parseInt(decimal, 10));

}

else if (hex) {

return String.fromCharCode(parseInt(hex, 16));

}

else {

const ch = entities.get(word);

// If this is not a valid entity, then just use `match` (replace it with itself, i.e. don't replace)

return ch ? String.fromCharCode(ch) : match;

}

});

}

/** Like `decodeEntities` but returns `undefined` if there were no entities to decode. */

function tryDecodeEntities(text: string): string | undefined {

const decoded = decodeEntities(text);

return decoded === text ? undefined : decoded;

}

function getTagName(node: JsxElement | JsxOpeningLikeElement): Expression {

if (node.kind === SyntaxKind.JsxElement) {

return getTagName(node.openingElement);

}

else {

const name = node.tagName;

if (isIdentifier(name) && isIntrinsicJsxName(name.escapedText)) {

return createLiteral(idText(name));

}

else {

return createExpressionFromEntityName(name);

}

}

}

/**

* Emit an attribute name, which is quoted if it needs to be quoted. Because

* these emit into an object literal property name, we don't need to be worried

* about keywords, just non-identifier characters

*/

function getAttributeName(node: JsxAttribute): StringLiteral | Identifier {

const name = node.name;

const text = idText(name);

if (/^[A-Za-z_]\w*$/.test(text)) {

return name;

}

else {

return createLiteral(text);

}

}

function visitJsxExpression(node: JsxExpression) {

return visitNode(node.expression, visitor, isExpression);

}