microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2026-05-20 13:45:34 -05:00
Code Issues Packages Projects Releases 212 Wiki Activity

Merge pull request #13188 from Microsoft/fix13147

Browse Source 
Fix UMD header to work with r.js
This commit is contained in:
Ron Buckton
2016-12-27 16:22:33 -08:00
committed by GitHub
parent 11dd368ec0 3b114f4a1e
commit 4fa8118b01
24 changed files with 298 additions and 207 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/compiler/emitter.ts
View File

@@ -670,8 +670,6 @@ namespace ts {
// Transformation nodes
case SyntaxKind.PartiallyEmittedExpression:
return emitPartiallyEmittedExpression(<PartiallyEmittedExpression>node);
case SyntaxKind.RawExpression:
return writeLines((<RawExpression>node).text);
}
}

13
src/compiler/factory.ts
View File

@@ -1530,19 +1530,6 @@ namespace ts {
return node;
}
/**
* Creates a node that emits a string of raw text in an expression position. Raw text is never
* transformed, should be ES3 compliant, and should have the same precedence as
* PrimaryExpression.
*
* @param text The raw text of the node.
*/
export function createRawExpression(text: string) {
const node = <RawExpression>createNode(SyntaxKind.RawExpression);
node.text = text;
return node;
}
// Compound nodes
export function createComma(left: Expression, right: Expression) {

165
src/compiler/transformers/module/module.ts
View File

@@ -102,28 +102,7 @@ namespace ts {
function transformAMDModule(node: SourceFile) {
const define = createIdentifier("define");
const moduleName = tryGetModuleNameFromFile(node, host, compilerOptions);
return transformAsynchronousModule(node, define, moduleName, /*includeNonAmdDependencies*/ true);
}
/**
* Transforms a SourceFile into a UMD module.
*
* @param node The SourceFile node.
*/
function transformUMDModule(node: SourceFile) {
const define = createRawExpression(umdHelper);
return transformAsynchronousModule(node, define, /*moduleName*/ undefined, /*includeNonAmdDependencies*/ false);
}
/**
* Transforms a SourceFile into an AMD or UMD module.
*
* @param node The SourceFile node.
* @param define The expression used to define the module.
* @param moduleName An expression for the module name, if available.
* @param includeNonAmdDependencies A value indicating whether to incldue any non-AMD dependencies.
*/
function transformAsynchronousModule(node: SourceFile, define: Expression, moduleName: Expression, includeNonAmdDependencies: boolean) {
// An AMD define function has the following shape:
//
// define(id?, dependencies?, factory);
@@ -145,7 +124,7 @@ namespace ts {
//
// we need to add modules without alias names to the end of the dependencies list
const { aliasedModuleNames, unaliasedModuleNames, importAliasNames } = collectAsynchronousDependencies(node, includeNonAmdDependencies);
const { aliasedModuleNames, unaliasedModuleNames, importAliasNames } = collectAsynchronousDependencies(node, /*includeNonAmdDependencies*/ true);
// Create an updated SourceFile:
//
@@ -194,6 +173,137 @@ namespace ts {
);
}
/**
* Transforms a SourceFile into a UMD module.
*
* @param node The SourceFile node.
*/
function transformUMDModule(node: SourceFile) {
const { aliasedModuleNames, unaliasedModuleNames, importAliasNames } = collectAsynchronousDependencies(node, /*includeNonAmdDependencies*/ false);
const umdHeader = createFunctionExpression(
/*modifiers*/ undefined,
/*asteriskToken*/ undefined,
/*name*/ undefined,
/*typeParameters*/ undefined,
[createParameter(/*decorators*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, "factory")],
/*type*/ undefined,
createBlock(
[
createIf(
createLogicalAnd(
createTypeCheck(createIdentifier("module"), "object"),
createTypeCheck(createPropertyAccess(createIdentifier("module"), "exports"), "object")
),
createBlock([
createVariableStatement(
/*modifiers*/ undefined,
[
createVariableDeclaration(
"v",
/*type*/ undefined,
createCall(
createIdentifier("factory"),
/*typeArguments*/ undefined,
[
createIdentifier("require"),
createIdentifier("exports")
]
)
)
]
),
setEmitFlags(
createIf(
createStrictInequality(
createIdentifier("v"),
createIdentifier("undefined")
),
createStatement(
createAssignment(
createPropertyAccess(createIdentifier("module"), "exports"),
createIdentifier("v")
)
)
),
EmitFlags.SingleLine
)
]),
createIf(
createLogicalAnd(
createTypeCheck(createIdentifier("define"), "function"),
createPropertyAccess(createIdentifier("define"), "amd")
),
createBlock([
createStatement(
createCall(
createIdentifier("define"),
/*typeArguments*/ undefined,
[
createArrayLiteral([
createLiteral("require"),
createLiteral("exports"),
...aliasedModuleNames,
...unaliasedModuleNames
]),
createIdentifier("factory")
]
)
)
])
)
)
],
/*location*/ undefined,
/*multiLine*/ true
)
);
// Create an updated SourceFile:
//
// (function (factory) {
// if (typeof module === "object" && typeof module.exports === "object") {
// var v = factory(require, exports);
// if (v !== undefined) module.exports = v;
// }
// else if (typeof define === 'function' && define.amd) {
// define(["require", "exports"], factory);
// }
// })(function ...)
return updateSourceFileNode(
node,
createNodeArray(
[
createStatement(
createCall(
umdHeader,
/*typeArguments*/ undefined,
[
// Add the module body function argument:
//
// function (require, exports) ...
createFunctionExpression(
/*modifiers*/ undefined,
/*asteriskToken*/ undefined,
/*name*/ undefined,
/*typeParameters*/ undefined,
[
createParameter(/*decorators*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, "require"),
createParameter(/*decorators*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, "exports"),
...importAliasNames
],
/*type*/ undefined,
transformAsynchronousModuleBody(node)
)
]
)
)
],
/*location*/ node.statements
)
);
}
/**
* Collect the additional asynchronous dependencies for the module.
*
@@ -1333,15 +1443,4 @@ namespace ts {
for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
}`
};
// emit output for the UMD helper function.
const umdHelper = `
(function (dependencies, factory) {
if (typeof module === 'object' && typeof module.exports === 'object') {
var v = factory(require, exports); if (v !== undefined) module.exports = v;
}
else if (typeof define === 'function' && define.amd) {
define(dependencies, factory);
}
})`;
}

11
src/compiler/types.ts
View File

@@ -370,7 +370,6 @@ namespace ts {
PartiallyEmittedExpression,
MergeDeclarationMarker,
EndOfDeclarationMarker,
RawExpression,
// Enum value count
Count,
@@ -1521,16 +1520,6 @@ namespace ts {
kind: SyntaxKind.EndOfDeclarationMarker;
}
/**
* Emits a string of raw text in an expression position. Raw text is never transformed, should
* be ES3 compliant, and should have the same precedence as PrimaryExpression.
*/
/* @internal */
export interface RawExpression extends PrimaryExpression {
kind: SyntaxKind.RawExpression;
text: string;
}
/**
* Marks the beginning of a merged transformed declaration.
*/

15
src/compiler/utilities.ts
View File

@@ -2141,7 +2141,6 @@ namespace ts {
case SyntaxKind.TemplateExpression:
case SyntaxKind.ParenthesizedExpression:
case SyntaxKind.OmittedExpression:
case SyntaxKind.RawExpression:
return 19;
case SyntaxKind.TaggedTemplateExpression:
@@ -2365,13 +2364,11 @@ namespace ts {
* Note that this doesn't actually wrap the input in double quotes.
*/
export function escapeString(s: string): string {
s = escapedCharsRegExp.test(s) ? s.replace(escapedCharsRegExp, getReplacement) : s;
return s.replace(escapedCharsRegExp, getReplacement);
}
return s;
function getReplacement(c: string) {
return escapedCharsMap[c] || get16BitUnicodeEscapeSequence(c.charCodeAt(0));
}
function getReplacement(c: string) {
return escapedCharsMap[c] || get16BitUnicodeEscapeSequence(c.charCodeAt(0));
}
export function isIntrinsicJsxName(name: string) {
@@ -3888,8 +3885,7 @@ namespace ts {
|| kind === SyntaxKind.ThisKeyword
|| kind === SyntaxKind.TrueKeyword
|| kind === SyntaxKind.SuperKeyword
|| kind === SyntaxKind.NonNullExpression
|| kind === SyntaxKind.RawExpression;
|| kind === SyntaxKind.NonNullExpression;
}
export function isLeftHandSideExpression(node: Node): node is LeftHandSideExpression {
@@ -3919,7 +3915,6 @@ namespace ts {
|| kind === SyntaxKind.SpreadElement
|| kind === SyntaxKind.AsExpression
|| kind === SyntaxKind.OmittedExpression
|| kind === SyntaxKind.RawExpression
|| isUnaryExpressionKind(kind);
}