biofriction-wp-theme/node_modules/babel-plugin-transform-es20.../lib/vanilla.js

559 lines
17 KiB
JavaScript
Raw Normal View History

2021-10-26 14:18:09 +02:00
"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"];