diff options
Diffstat (limited to 'node_modules/babel-plugin-transform-es2015-classes')
7 files changed, 902 insertions, 0 deletions
diff --git a/node_modules/babel-plugin-transform-es2015-classes/.npmignore b/node_modules/babel-plugin-transform-es2015-classes/.npmignore new file mode 100644 index 0000000..3185290 --- /dev/null +++ b/node_modules/babel-plugin-transform-es2015-classes/.npmignore @@ -0,0 +1,4 @@ +node_modules +*.log +src +test diff --git a/node_modules/babel-plugin-transform-es2015-classes/README.md b/node_modules/babel-plugin-transform-es2015-classes/README.md new file mode 100644 index 0000000..c189adf --- /dev/null +++ b/node_modules/babel-plugin-transform-es2015-classes/README.md @@ -0,0 +1,85 @@ +# babel-plugin-transform-es2015-classes + +> Compile ES2015 classes to ES5 + +## Caveats + +Built-in classes such as `Date`, `Array`, `DOM` etc cannot be properly subclassed +due to limitations in ES5 (for the [es2015-classes](http://babeljs.io/docs/plugins/transform-es2015-classes) plugin). +You can try to use [babel-plugin-transform-builtin-extend](https://github.com/loganfsmyth/babel-plugin-transform-builtin-extend) based on `Object.setPrototypeOf` and `Reflect.construct`, but it also has some limitations. + +## Installation + +```sh +npm install --save-dev babel-plugin-transform-es2015-classes +``` + +## Usage + +### Via `.babelrc` (Recommended) + +**.babelrc** + +```js +// without options +{ + "plugins": ["transform-es2015-classes"] +} + +// with options +{ + "plugins": [ + ["transform-es2015-classes", { + "loose": true + }] + ] +} +``` + +### Via CLI + +```sh +babel --plugins transform-es2015-classes script.js +``` + +### Via Node API + +```javascript +require("babel-core").transform("code", { + plugins: ["transform-es2015-classes"] +}); +``` + +## Options + +### `loose` + +`boolean`, defaults to `false`. + +#### Method enumerability + +Please note that in loose mode class methods **are** enumerable. This is not in line +with the spec and you may run into issues. + +#### Method assignment + +Under loose mode, methods are defined on the class prototype with simple assignments +instead of being defined. This can result in the following not working: + +```javascript +class Foo { + set bar() { + throw new Error("foo!"); + } +} + +class Bar extends Foo { + bar() { + // will throw an error when this method is defined + } +} +``` + +When `Bar.prototype.foo` is defined it triggers the setter on `Foo`. This is a +case that is very unlikely to appear in production code however it's something +to keep in mind. diff --git a/node_modules/babel-plugin-transform-es2015-classes/lib/index.js b/node_modules/babel-plugin-transform-es2015-classes/lib/index.js new file mode 100644 index 0000000..9f4c0a9 --- /dev/null +++ b/node_modules/babel-plugin-transform-es2015-classes/lib/index.js @@ -0,0 +1,68 @@ +"use strict"; + +exports.__esModule = true; + +var _symbol = require("babel-runtime/core-js/symbol"); + +var _symbol2 = _interopRequireDefault(_symbol); + +exports.default = function (_ref) { + var t = _ref.types; + + var VISITED = (0, _symbol2.default)(); + + return { + visitor: { + ExportDefaultDeclaration: function ExportDefaultDeclaration(path) { + if (!path.get("declaration").isClassDeclaration()) return; + + var node = path.node; + + var ref = node.declaration.id || path.scope.generateUidIdentifier("class"); + node.declaration.id = ref; + + path.replaceWith(node.declaration); + path.insertAfter(t.exportDefaultDeclaration(ref)); + }, + ClassDeclaration: function ClassDeclaration(path) { + var node = path.node; + + + var ref = node.id || path.scope.generateUidIdentifier("class"); + + path.replaceWith(t.variableDeclaration("let", [t.variableDeclarator(ref, t.toExpression(node))])); + }, + ClassExpression: function ClassExpression(path, state) { + var node = path.node; + + if (node[VISITED]) return; + + var inferred = (0, _babelHelperFunctionName2.default)(path); + if (inferred && inferred !== node) return path.replaceWith(inferred); + + node[VISITED] = true; + + var Constructor = _vanilla2.default; + if (state.opts.loose) Constructor = _loose2.default; + + path.replaceWith(new Constructor(path, state.file).run()); + } + } + }; +}; + +var _loose = require("./loose"); + +var _loose2 = _interopRequireDefault(_loose); + +var _vanilla = require("./vanilla"); + +var _vanilla2 = _interopRequireDefault(_vanilla); + +var _babelHelperFunctionName = require("babel-helper-function-name"); + +var _babelHelperFunctionName2 = _interopRequireDefault(_babelHelperFunctionName); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +module.exports = exports["default"];
\ No newline at end of file diff --git a/node_modules/babel-plugin-transform-es2015-classes/lib/lib/memoise-decorators.js b/node_modules/babel-plugin-transform-es2015-classes/lib/lib/memoise-decorators.js new file mode 100644 index 0000000..a5e1a74 --- /dev/null +++ b/node_modules/babel-plugin-transform-es2015-classes/lib/lib/memoise-decorators.js @@ -0,0 +1,59 @@ +"use strict"; + +exports.__esModule = true; + +var _getIterator2 = require("babel-runtime/core-js/get-iterator"); + +var _getIterator3 = _interopRequireDefault(_getIterator2); + +exports.default = function (decorators, scope) { + for (var _iterator = decorators, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : (0, _getIterator3.default)(_iterator);;) { + var _ref; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + var decorator = _ref; + + var expression = decorator.expression; + if (!t.isMemberExpression(expression)) continue; + + var temp = scope.maybeGenerateMemoised(expression.object); + var ref = void 0; + + var nodes = []; + + if (temp) { + ref = temp; + nodes.push(t.assignmentExpression("=", temp, expression.object)); + } else { + ref = expression.object; + } + + nodes.push(t.callExpression(t.memberExpression(t.memberExpression(ref, expression.property, expression.computed), t.identifier("bind")), [ref])); + + if (nodes.length === 1) { + decorator.expression = nodes[0]; + } else { + decorator.expression = t.sequenceExpression(nodes); + } + } + + return decorators; +}; + +var _babelTypes = require("babel-types"); + +var t = _interopRequireWildcard(_babelTypes); + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +module.exports = exports["default"];
\ No newline at end of file diff --git a/node_modules/babel-plugin-transform-es2015-classes/lib/loose.js b/node_modules/babel-plugin-transform-es2015-classes/lib/loose.js new file mode 100644 index 0000000..be11b63 --- /dev/null +++ b/node_modules/babel-plugin-transform-es2015-classes/lib/loose.js @@ -0,0 +1,74 @@ +"use strict"; + +exports.__esModule = true; + +var _classCallCheck2 = require("babel-runtime/helpers/classCallCheck"); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _possibleConstructorReturn2 = require("babel-runtime/helpers/possibleConstructorReturn"); + +var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2); + +var _inherits2 = require("babel-runtime/helpers/inherits"); + +var _inherits3 = _interopRequireDefault(_inherits2); + +var _babelHelperFunctionName = require("babel-helper-function-name"); + +var _babelHelperFunctionName2 = _interopRequireDefault(_babelHelperFunctionName); + +var _vanilla = require("./vanilla"); + +var _vanilla2 = _interopRequireDefault(_vanilla); + +var _babelTypes = require("babel-types"); + +var t = _interopRequireWildcard(_babelTypes); + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var LooseClassTransformer = function (_VanillaTransformer) { + (0, _inherits3.default)(LooseClassTransformer, _VanillaTransformer); + + function LooseClassTransformer() { + (0, _classCallCheck3.default)(this, LooseClassTransformer); + + var _this = (0, _possibleConstructorReturn3.default)(this, _VanillaTransformer.apply(this, arguments)); + + _this.isLoose = true; + return _this; + } + + LooseClassTransformer.prototype._processMethod = function _processMethod(node, scope) { + if (!node.decorators) { + + var classRef = this.classRef; + if (!node.static) classRef = t.memberExpression(classRef, t.identifier("prototype")); + var methodName = t.memberExpression(classRef, node.key, node.computed || t.isLiteral(node.key)); + + var func = t.functionExpression(null, node.params, node.body, node.generator, node.async); + func.returnType = node.returnType; + var key = t.toComputedKey(node, node.key); + if (t.isStringLiteral(key)) { + func = (0, _babelHelperFunctionName2.default)({ + node: func, + id: key, + scope: scope + }); + } + + var expr = t.expressionStatement(t.assignmentExpression("=", methodName, func)); + t.inheritsComments(expr, node); + this.body.push(expr); + return true; + } + }; + + return LooseClassTransformer; +}(_vanilla2.default); + +exports.default = LooseClassTransformer; +module.exports = exports["default"];
\ No newline at end of file diff --git a/node_modules/babel-plugin-transform-es2015-classes/lib/vanilla.js b/node_modules/babel-plugin-transform-es2015-classes/lib/vanilla.js new file mode 100644 index 0000000..8fd9ac3 --- /dev/null +++ b/node_modules/babel-plugin-transform-es2015-classes/lib/vanilla.js @@ -0,0 +1,559 @@ +"use strict"; + +exports.__esModule = true; + +var _getIterator2 = require("babel-runtime/core-js/get-iterator"); + +var _getIterator3 = _interopRequireDefault(_getIterator2); + +var _classCallCheck2 = require("babel-runtime/helpers/classCallCheck"); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _babelTraverse = require("babel-traverse"); + +var _babelHelperReplaceSupers = require("babel-helper-replace-supers"); + +var _babelHelperReplaceSupers2 = _interopRequireDefault(_babelHelperReplaceSupers); + +var _babelHelperOptimiseCallExpression = require("babel-helper-optimise-call-expression"); + +var _babelHelperOptimiseCallExpression2 = _interopRequireDefault(_babelHelperOptimiseCallExpression); + +var _babelHelperDefineMap = require("babel-helper-define-map"); + +var defineMap = _interopRequireWildcard(_babelHelperDefineMap); + +var _babelTemplate = require("babel-template"); + +var _babelTemplate2 = _interopRequireDefault(_babelTemplate); + +var _babelTypes = require("babel-types"); + +var t = _interopRequireWildcard(_babelTypes); + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var buildDerivedConstructor = (0, _babelTemplate2.default)("\n (function () {\n super(...arguments);\n })\n"); + +var noMethodVisitor = { + "FunctionExpression|FunctionDeclaration": function FunctionExpressionFunctionDeclaration(path) { + if (!path.is("shadow")) { + path.skip(); + } + }, + Method: function Method(path) { + path.skip(); + } +}; + +var verifyConstructorVisitor = _babelTraverse.visitors.merge([noMethodVisitor, { + Super: function Super(path) { + if (this.isDerived && !this.hasBareSuper && !path.parentPath.isCallExpression({ callee: path.node })) { + throw path.buildCodeFrameError("'super.*' is not allowed before super()"); + } + }, + + + CallExpression: { + exit: function exit(path) { + if (path.get("callee").isSuper()) { + this.hasBareSuper = true; + + if (!this.isDerived) { + throw path.buildCodeFrameError("super() is only allowed in a derived constructor"); + } + } + } + }, + + ThisExpression: function ThisExpression(path) { + if (this.isDerived && !this.hasBareSuper) { + if (!path.inShadow("this")) { + throw path.buildCodeFrameError("'this' is not allowed before super()"); + } + } + } +}]); + +var findThisesVisitor = _babelTraverse.visitors.merge([noMethodVisitor, { + ThisExpression: function ThisExpression(path) { + this.superThises.push(path); + } +}]); + +var ClassTransformer = function () { + function ClassTransformer(path, file) { + (0, _classCallCheck3.default)(this, ClassTransformer); + + this.parent = path.parent; + this.scope = path.scope; + this.node = path.node; + this.path = path; + this.file = file; + + this.clearDescriptors(); + + this.instancePropBody = []; + this.instancePropRefs = {}; + this.staticPropBody = []; + this.body = []; + + this.bareSuperAfter = []; + this.bareSupers = []; + + this.pushedConstructor = false; + this.pushedInherits = false; + this.isLoose = false; + + this.superThises = []; + + this.classId = this.node.id; + + this.classRef = this.node.id ? t.identifier(this.node.id.name) : this.scope.generateUidIdentifier("class"); + + this.superName = this.node.superClass || t.identifier("Function"); + this.isDerived = !!this.node.superClass; + } + + ClassTransformer.prototype.run = function run() { + var _this = this; + + var superName = this.superName; + var file = this.file; + var body = this.body; + + var constructorBody = this.constructorBody = t.blockStatement([]); + this.constructor = this.buildConstructor(); + + var closureParams = []; + var closureArgs = []; + + if (this.isDerived) { + closureArgs.push(superName); + + superName = this.scope.generateUidIdentifierBasedOnNode(superName); + closureParams.push(superName); + + this.superName = superName; + } + + this.buildBody(); + + constructorBody.body.unshift(t.expressionStatement(t.callExpression(file.addHelper("classCallCheck"), [t.thisExpression(), this.classRef]))); + + body = body.concat(this.staticPropBody.map(function (fn) { + return fn(_this.classRef); + })); + + if (this.classId) { + if (body.length === 1) return t.toExpression(body[0]); + } + + body.push(t.returnStatement(this.classRef)); + + var container = t.functionExpression(null, closureParams, t.blockStatement(body)); + container.shadow = true; + return t.callExpression(container, closureArgs); + }; + + ClassTransformer.prototype.buildConstructor = function buildConstructor() { + var func = t.functionDeclaration(this.classRef, [], this.constructorBody); + t.inherits(func, this.node); + return func; + }; + + ClassTransformer.prototype.pushToMap = function pushToMap(node, enumerable) { + var kind = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : "value"; + var scope = arguments[3]; + + var mutatorMap = void 0; + if (node.static) { + this.hasStaticDescriptors = true; + mutatorMap = this.staticMutatorMap; + } else { + this.hasInstanceDescriptors = true; + mutatorMap = this.instanceMutatorMap; + } + + var map = defineMap.push(mutatorMap, node, kind, this.file, scope); + + if (enumerable) { + map.enumerable = t.booleanLiteral(true); + } + + return map; + }; + + ClassTransformer.prototype.constructorMeMaybe = function constructorMeMaybe() { + var hasConstructor = false; + var paths = this.path.get("body.body"); + for (var _iterator = paths, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : (0, _getIterator3.default)(_iterator);;) { + var _ref; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + var path = _ref; + + hasConstructor = path.equals("kind", "constructor"); + if (hasConstructor) break; + } + if (hasConstructor) return; + + var params = void 0, + body = void 0; + + if (this.isDerived) { + var _constructor = buildDerivedConstructor().expression; + params = _constructor.params; + body = _constructor.body; + } else { + params = []; + body = t.blockStatement([]); + } + + this.path.get("body").unshiftContainer("body", t.classMethod("constructor", t.identifier("constructor"), params, body)); + }; + + ClassTransformer.prototype.buildBody = function buildBody() { + this.constructorMeMaybe(); + this.pushBody(); + this.verifyConstructor(); + + if (this.userConstructor) { + var constructorBody = this.constructorBody; + constructorBody.body = constructorBody.body.concat(this.userConstructor.body.body); + t.inherits(this.constructor, this.userConstructor); + t.inherits(constructorBody, this.userConstructor.body); + } + + this.pushDescriptors(); + }; + + ClassTransformer.prototype.pushBody = function pushBody() { + var classBodyPaths = this.path.get("body.body"); + + for (var _iterator2 = classBodyPaths, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : (0, _getIterator3.default)(_iterator2);;) { + var _ref2; + + if (_isArray2) { + if (_i2 >= _iterator2.length) break; + _ref2 = _iterator2[_i2++]; + } else { + _i2 = _iterator2.next(); + if (_i2.done) break; + _ref2 = _i2.value; + } + + var path = _ref2; + + var node = path.node; + + if (path.isClassProperty()) { + throw path.buildCodeFrameError("Missing class properties transform."); + } + + if (node.decorators) { + throw path.buildCodeFrameError("Method has decorators, put the decorator plugin before the classes one."); + } + + if (t.isClassMethod(node)) { + var isConstructor = node.kind === "constructor"; + + if (isConstructor) { + path.traverse(verifyConstructorVisitor, this); + + if (!this.hasBareSuper && this.isDerived) { + throw path.buildCodeFrameError("missing super() call in constructor"); + } + } + + var replaceSupers = new _babelHelperReplaceSupers2.default({ + forceSuperMemoisation: isConstructor, + methodPath: path, + methodNode: node, + objectRef: this.classRef, + superRef: this.superName, + isStatic: node.static, + isLoose: this.isLoose, + scope: this.scope, + file: this.file + }, true); + + replaceSupers.replace(); + + if (isConstructor) { + this.pushConstructor(replaceSupers, node, path); + } else { + this.pushMethod(node, path); + } + } + } + }; + + ClassTransformer.prototype.clearDescriptors = function clearDescriptors() { + this.hasInstanceDescriptors = false; + this.hasStaticDescriptors = false; + + this.instanceMutatorMap = {}; + this.staticMutatorMap = {}; + }; + + ClassTransformer.prototype.pushDescriptors = function pushDescriptors() { + this.pushInherits(); + + var body = this.body; + + var instanceProps = void 0; + var staticProps = void 0; + + if (this.hasInstanceDescriptors) { + instanceProps = defineMap.toClassObject(this.instanceMutatorMap); + } + + if (this.hasStaticDescriptors) { + staticProps = defineMap.toClassObject(this.staticMutatorMap); + } + + if (instanceProps || staticProps) { + if (instanceProps) instanceProps = defineMap.toComputedObjectFromClass(instanceProps); + if (staticProps) staticProps = defineMap.toComputedObjectFromClass(staticProps); + + var nullNode = t.nullLiteral(); + + var args = [this.classRef, nullNode, nullNode, nullNode, nullNode]; + + if (instanceProps) args[1] = instanceProps; + if (staticProps) args[2] = staticProps; + + if (this.instanceInitializersId) { + args[3] = this.instanceInitializersId; + body.unshift(this.buildObjectAssignment(this.instanceInitializersId)); + } + + if (this.staticInitializersId) { + args[4] = this.staticInitializersId; + body.unshift(this.buildObjectAssignment(this.staticInitializersId)); + } + + var lastNonNullIndex = 0; + for (var i = 0; i < args.length; i++) { + if (args[i] !== nullNode) lastNonNullIndex = i; + } + args = args.slice(0, lastNonNullIndex + 1); + + body.push(t.expressionStatement(t.callExpression(this.file.addHelper("createClass"), args))); + } + + this.clearDescriptors(); + }; + + ClassTransformer.prototype.buildObjectAssignment = function buildObjectAssignment(id) { + return t.variableDeclaration("var", [t.variableDeclarator(id, t.objectExpression([]))]); + }; + + ClassTransformer.prototype.wrapSuperCall = function wrapSuperCall(bareSuper, superRef, thisRef, body) { + var bareSuperNode = bareSuper.node; + + if (this.isLoose) { + bareSuperNode.arguments.unshift(t.thisExpression()); + if (bareSuperNode.arguments.length === 2 && t.isSpreadElement(bareSuperNode.arguments[1]) && t.isIdentifier(bareSuperNode.arguments[1].argument, { name: "arguments" })) { + bareSuperNode.arguments[1] = bareSuperNode.arguments[1].argument; + bareSuperNode.callee = t.memberExpression(superRef, t.identifier("apply")); + } else { + bareSuperNode.callee = t.memberExpression(superRef, t.identifier("call")); + } + } else { + bareSuperNode = (0, _babelHelperOptimiseCallExpression2.default)(t.logicalExpression("||", t.memberExpression(this.classRef, t.identifier("__proto__")), t.callExpression(t.memberExpression(t.identifier("Object"), t.identifier("getPrototypeOf")), [this.classRef])), t.thisExpression(), bareSuperNode.arguments); + } + + var call = t.callExpression(this.file.addHelper("possibleConstructorReturn"), [t.thisExpression(), bareSuperNode]); + + var bareSuperAfter = this.bareSuperAfter.map(function (fn) { + return fn(thisRef); + }); + + if (bareSuper.parentPath.isExpressionStatement() && bareSuper.parentPath.container === body.node.body && body.node.body.length - 1 === bareSuper.parentPath.key) { + + if (this.superThises.length || bareSuperAfter.length) { + bareSuper.scope.push({ id: thisRef }); + call = t.assignmentExpression("=", thisRef, call); + } + + if (bareSuperAfter.length) { + call = t.toSequenceExpression([call].concat(bareSuperAfter, [thisRef])); + } + + bareSuper.parentPath.replaceWith(t.returnStatement(call)); + } else { + bareSuper.replaceWithMultiple([t.variableDeclaration("var", [t.variableDeclarator(thisRef, call)])].concat(bareSuperAfter, [t.expressionStatement(thisRef)])); + } + }; + + ClassTransformer.prototype.verifyConstructor = function verifyConstructor() { + var _this2 = this; + + if (!this.isDerived) return; + + var path = this.userConstructorPath; + var body = path.get("body"); + + path.traverse(findThisesVisitor, this); + + var guaranteedSuperBeforeFinish = !!this.bareSupers.length; + + var superRef = this.superName || t.identifier("Function"); + var thisRef = path.scope.generateUidIdentifier("this"); + + for (var _iterator3 = this.bareSupers, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : (0, _getIterator3.default)(_iterator3);;) { + var _ref3; + + if (_isArray3) { + if (_i3 >= _iterator3.length) break; + _ref3 = _iterator3[_i3++]; + } else { + _i3 = _iterator3.next(); + if (_i3.done) break; + _ref3 = _i3.value; + } + + var bareSuper = _ref3; + + this.wrapSuperCall(bareSuper, superRef, thisRef, body); + + if (guaranteedSuperBeforeFinish) { + bareSuper.find(function (parentPath) { + if (parentPath === path) { + return true; + } + + if (parentPath.isLoop() || parentPath.isConditional()) { + guaranteedSuperBeforeFinish = false; + return true; + } + }); + } + } + + for (var _iterator4 = this.superThises, _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : (0, _getIterator3.default)(_iterator4);;) { + var _ref4; + + if (_isArray4) { + if (_i4 >= _iterator4.length) break; + _ref4 = _iterator4[_i4++]; + } else { + _i4 = _iterator4.next(); + if (_i4.done) break; + _ref4 = _i4.value; + } + + var thisPath = _ref4; + + thisPath.replaceWith(thisRef); + } + + var wrapReturn = function wrapReturn(returnArg) { + return t.callExpression(_this2.file.addHelper("possibleConstructorReturn"), [thisRef].concat(returnArg || [])); + }; + + var bodyPaths = body.get("body"); + if (bodyPaths.length && !bodyPaths.pop().isReturnStatement()) { + body.pushContainer("body", t.returnStatement(guaranteedSuperBeforeFinish ? thisRef : wrapReturn())); + } + + for (var _iterator5 = this.superReturns, _isArray5 = Array.isArray(_iterator5), _i5 = 0, _iterator5 = _isArray5 ? _iterator5 : (0, _getIterator3.default)(_iterator5);;) { + var _ref5; + + if (_isArray5) { + if (_i5 >= _iterator5.length) break; + _ref5 = _iterator5[_i5++]; + } else { + _i5 = _iterator5.next(); + if (_i5.done) break; + _ref5 = _i5.value; + } + + var returnPath = _ref5; + + if (returnPath.node.argument) { + var ref = returnPath.scope.generateDeclaredUidIdentifier("ret"); + returnPath.get("argument").replaceWithMultiple([t.assignmentExpression("=", ref, returnPath.node.argument), wrapReturn(ref)]); + } else { + returnPath.get("argument").replaceWith(wrapReturn()); + } + } + }; + + ClassTransformer.prototype.pushMethod = function pushMethod(node, path) { + var scope = path ? path.scope : this.scope; + + if (node.kind === "method") { + if (this._processMethod(node, scope)) return; + } + + this.pushToMap(node, false, null, scope); + }; + + ClassTransformer.prototype._processMethod = function _processMethod() { + return false; + }; + + ClassTransformer.prototype.pushConstructor = function pushConstructor(replaceSupers, method, path) { + this.bareSupers = replaceSupers.bareSupers; + this.superReturns = replaceSupers.returns; + + if (path.scope.hasOwnBinding(this.classRef.name)) { + path.scope.rename(this.classRef.name); + } + + var construct = this.constructor; + + this.userConstructorPath = path; + this.userConstructor = method; + this.hasConstructor = true; + + t.inheritsComments(construct, method); + + construct._ignoreUserWhitespace = true; + construct.params = method.params; + + t.inherits(construct.body, method.body); + construct.body.directives = method.body.directives; + + this._pushConstructor(); + }; + + ClassTransformer.prototype._pushConstructor = function _pushConstructor() { + if (this.pushedConstructor) return; + this.pushedConstructor = true; + + if (this.hasInstanceDescriptors || this.hasStaticDescriptors) { + this.pushDescriptors(); + } + + this.body.push(this.constructor); + + this.pushInherits(); + }; + + ClassTransformer.prototype.pushInherits = function pushInherits() { + if (!this.isDerived || this.pushedInherits) return; + + this.pushedInherits = true; + this.body.unshift(t.expressionStatement(t.callExpression(this.file.addHelper("inherits"), [this.classRef, this.superName]))); + }; + + return ClassTransformer; +}(); + +exports.default = ClassTransformer; +module.exports = exports["default"];
\ No newline at end of file diff --git a/node_modules/babel-plugin-transform-es2015-classes/package.json b/node_modules/babel-plugin-transform-es2015-classes/package.json new file mode 100644 index 0000000..8eee2e0 --- /dev/null +++ b/node_modules/babel-plugin-transform-es2015-classes/package.json @@ -0,0 +1,53 @@ +{ + "_from": "babel-plugin-transform-es2015-classes@^6.24.1", + "_id": "babel-plugin-transform-es2015-classes@6.24.1", + "_inBundle": false, + "_integrity": "sha1-WkxYpQyclGHlZLSyo7+ryXolhNs=", + "_location": "/babel-plugin-transform-es2015-classes", + "_phantomChildren": {}, + "_requested": { + "type": "range", + "registry": true, + "raw": "babel-plugin-transform-es2015-classes@^6.24.1", + "name": "babel-plugin-transform-es2015-classes", + "escapedName": "babel-plugin-transform-es2015-classes", + "rawSpec": "^6.24.1", + "saveSpec": null, + "fetchSpec": "^6.24.1" + }, + "_requiredBy": [ + "/babel-preset-es2015" + ], + "_resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-classes/-/babel-plugin-transform-es2015-classes-6.24.1.tgz", + "_shasum": "5a4c58a50c9c9461e564b4b2a3bfabc97a2584db", + "_spec": "babel-plugin-transform-es2015-classes@^6.24.1", + "_where": "/home/pruss/Dev/3-minute-website/node_modules/babel-preset-es2015", + "bundleDependencies": false, + "dependencies": { + "babel-helper-define-map": "^6.24.1", + "babel-helper-function-name": "^6.24.1", + "babel-helper-optimise-call-expression": "^6.24.1", + "babel-helper-replace-supers": "^6.24.1", + "babel-messages": "^6.23.0", + "babel-runtime": "^6.22.0", + "babel-template": "^6.24.1", + "babel-traverse": "^6.24.1", + "babel-types": "^6.24.1" + }, + "deprecated": false, + "description": "Compile ES2015 classes to ES5", + "devDependencies": { + "babel-helper-plugin-test-runner": "^6.24.1" + }, + "keywords": [ + "babel-plugin" + ], + "license": "MIT", + "main": "lib/index.js", + "name": "babel-plugin-transform-es2015-classes", + "repository": { + "type": "git", + "url": "https://github.com/babel/babel/tree/master/packages/babel-plugin-transform-es2015-classes" + }, + "version": "6.24.1" +} |