1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139 | 1
1
1
1
1
1
244
3
1
1
122
122
122
122
122
122
121
120
1
120
120
1962
1962
1961
1961
1945
113
113
1
113
113
113
1
1945
3890
105849
105849
4622
4622
4622
2376
1945
1
122
122
122
122
122
122
113
113
113
113
113
113
113
113
1
113
2
2
2
2
2
1
| var sourceMap = require("source-map");
var traverse = require("./traverse");
var recast = require("recast");
var util = require("./util");
var _ = require("lodash");
var ensureTransformerNames = function (type, keys) {
_.each(keys, function (key) {
if (!transform.transformers[key]) {
throw new ReferenceError("unknown transformer " + key + " specified in " + type);
}
});
};
var transform = module.exports = function (code, opts) {
opts = opts || {};
code = (code || "") + "";
_.defaults(opts, {
blacklist: [],
whitelist: [],
sourceMap: false,
filename: "unknown",
format: {}
});
_.defaults(opts, {
sourceFileName: opts.filename,
sourceMapName: opts.filename
});
ensureTransformerNames("blacklist", opts.blacklist);
ensureTransformerNames("whitelist", opts.whitelist);
return util.parse(opts, code, function (tree) {
return transform._run(code, tree, opts);
});
};
transform._run = function (code, tree, opts) {
var generateUid = util.buildUidGenerator();
_.each(transform.transformers, function (transformer, name) {
var blacklist = opts.blacklist;
if (blacklist.length && _.contains(blacklist, name)) return;
var whitelist = opts.whitelist;
if (whitelist.length && !_.contains(whitelist, name)) return;
transform._runTransformer(transformer, tree, opts, generateUid);
});
var result = util.generate(tree, opts);
if (opts.sourceMap === "inline") {
result.code += "\n" + util.sourceMapToComment(result.map);
}
result.map = result.map || null;
result.ast = tree;
return result;
};
transform._runTransformer = function (transformer, tree, opts, generateUid) {
var build = function (exit) {
return function (node, parent) {
var fns = transformer[node.type] || transformer.all;
if (!fns) return;
var fn = fns.enter || fns;
if (exit) fn = fns.exit;
if (!fn || !_.isFunction(fn)) return;
return fn(node, parent, opts, generateUid);
};
};
traverse(tree, {
enter: build(),
exit: build(true)
});
};
transform.test = function (task, assert) {
var actual = task.actual;
var expect = task.expect;
var opts = task.options;
opts.filename = actual.filename;
var actualCode = actual.code.trim();
var actualResult = transform(actualCode, opts);
var actualAst = actualResult.ast;
actualCode = recast.prettyPrint(actualAst).code;
var expectCode = expect.code.trim();
var expectAst = util.parse(expect, expectCode);
var expectResult = recast.prettyPrint(expectAst);
expectCode = expectResult.code;
assert.equal(actualCode, expectCode);
if (task.sourceMap) {
assert.deepEqual(task.sourceMap, actualResult.map);
}
if (task.sourceMappings) {
var consumer = new sourceMap.SourceMapConsumer(actualResult.map);
_.each(task.sourceMappings, function (mapping, i) {
var pos = consumer.originalPositionFor(mapping.generated);
var msg = "source mapping " + ++i + " - generated: " + mapping.generated.line + ":" + mapping.generated.column;
assert.equal(pos.line + ":" + pos.column, mapping.original.line + ":" + mapping.original.column, msg);
});
}
};
transform.transformers = {
modules: require("./transformers/modules"),
computedPropertyNames: require("./transformers/computed-property-names"),
propertyNameShorthand: require("./transformers/property-name-shorthand"),
constants: require("./transformers/constants"),
arrayComprehension: require("./transformers/array-comprehension"),
arrowFunctions: require("./transformers/arrow-functions"),
classes: require("./transformers/classes"),
spread: require("./transformers/spread"),
templateLiterals: require("./transformers/template-literals"),
propertyMethodAssignment: require("./transformers/property-method-assignment"),
defaultParameters: require("./transformers/default-parameters"),
generators: require("./transformers/generators"),
blockBinding: require("./transformers/block-binding"),
restParameters: require("./transformers/rest-parameters"),
destructuring: require("./transformers/destructuring"),
forOf: require("./transformers/for-of"),
unicodeRegex: require("./transformers/unicode-regex")
};
|