babel-transform-webpack-plugin
Version:
A webpack plugin to transform javascript chunks using babel.
927 lines (926 loc) • 42.4 kB
JavaScript
import * as __WEBPACK_EXTERNAL_MODULE_os__ from "os";
import * as __WEBPACK_EXTERNAL_MODULE__babel_core_1832d21b__ from "@babel/core";
function _array_like_to_array(arr, len) {
if (null == len || len > arr.length) len = arr.length;
for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
return arr2;
}
function _array_with_holes(arr) {
if (Array.isArray(arr)) return arr;
}
function _async_generator(gen) {
var front, back;
function send(key, arg) {
return new Promise(function(resolve, reject) {
var request = {
key: key,
arg: arg,
resolve: resolve,
reject: reject,
next: null
};
if (back) back = back.next = request;
else {
front = back = request;
resume(key, arg);
}
});
}
function resume(key, arg) {
try {
var result = gen[key](arg);
var value = result.value;
var wrappedAwait = value instanceof _await_value;
Promise.resolve(wrappedAwait ? value.wrapped : value).then(function(arg) {
if (wrappedAwait) {
resume("next", arg);
return;
}
settle(result.done ? "return" : "normal", arg);
}, function(err) {
resume("throw", err);
});
} catch (err) {
settle("throw", err);
}
}
function settle(type, value) {
switch(type){
case "return":
front.resolve({
value: value,
done: true
});
break;
case "throw":
front.reject(value);
break;
default:
front.resolve({
value: value,
done: false
});
break;
}
front = front.next;
if (front) resume(front.key, front.arg);
else back = null;
}
this._invoke = send;
if ("function" != typeof gen.return) this.return = void 0;
}
if ("function" == typeof Symbol && Symbol.asyncIterator) _async_generator.prototype[Symbol.asyncIterator] = function() {
return this;
};
_async_generator.prototype.next = function(arg) {
return this._invoke("next", arg);
};
_async_generator.prototype.throw = function(arg) {
return this._invoke("throw", arg);
};
_async_generator.prototype.return = function(arg) {
return this._invoke("return", arg);
};
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
try {
var info = gen[key](arg);
var value = info.value;
} catch (error) {
reject(error);
return;
}
if (info.done) resolve(value);
else Promise.resolve(value).then(_next, _throw);
}
function _async_to_generator(fn) {
return function() {
var self = this, args = arguments;
return new Promise(function(resolve, reject) {
var gen = fn.apply(self, args);
function _next(value) {
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
}
function _throw(err) {
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
}
_next(void 0);
});
};
}
function _await_value(value) {
this.wrapped = value;
}
function _iterable_to_array_limit(arr, i) {
var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"];
if (null == _i) return;
var _arr = [];
var _n = true;
var _d = false;
var _s, _e;
try {
for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
_arr.push(_s.value);
if (i && _arr.length === i) break;
}
} catch (err) {
_d = true;
_e = err;
} finally{
try {
if (!_n && null != _i["return"]) _i["return"]();
} finally{
if (_d) throw _e;
}
}
return _arr;
}
function _non_iterable_rest() {
throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _sliced_to_array(arr, i) {
return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
}
function _type_of(obj) {
return obj && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
}
function _unsupported_iterable_to_array(o, minLen) {
if (!o) return;
if ("string" == typeof o) return _array_like_to_array(o, minLen);
var n = Object.prototype.toString.call(o).slice(8, -1);
if ("Object" === n && o.constructor) n = o.constructor.name;
if ("Map" === n || "Set" === n) return Array.from(n);
if ("Arguments" === n || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
}
function _ts_generator(thisArg, body) {
var f, y, t, g, _ = {
label: 0,
sent: function() {
if (1 & t[0]) throw t[1];
return t[1];
},
trys: [],
ops: []
};
return g = {
next: verb(0),
throw: verb(1),
return: verb(2)
}, "function" == typeof Symbol && (g[Symbol.iterator] = function() {
return this;
}), g;
function verb(n) {
return function(v) {
return step([
n,
v
]);
};
}
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while(_)try {
if (f = 1, y && (t = 2 & op[0] ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [
2 & op[0],
t.value
];
switch(op[0]){
case 0:
case 1:
t = op;
break;
case 4:
_.label++;
return {
value: op[1],
done: false
};
case 5:
_.label++;
y = op[1];
op = [
0
];
continue;
case 7:
op = _.ops.pop();
_.trys.pop();
continue;
default:
if (t = _.trys, !(t = t.length > 0 && t[t.length - 1]) && (6 === op[0] || 2 === op[0])) {
_ = 0;
continue;
}
if (3 === op[0] && (!t || op[1] > t[0] && op[1] < t[3])) {
_.label = op[1];
break;
}
if (6 === op[0] && _.label < t[1]) {
_.label = t[1];
t = op;
break;
}
if (t && _.label < t[2]) {
_.label = t[2];
_.ops.push(op);
break;
}
if (t[2]) _.ops.pop();
_.trys.pop();
continue;
}
op = body.call(thisArg, _);
} catch (e) {
op = [
6,
e
];
y = 0;
} finally{
f = t = 0;
}
if (5 & op[0]) throw op[1];
return {
value: op[0] ? op[1] : void 0,
done: true
};
}
}
function pMap(iterable, mapper) {
return _pMap.apply(this, arguments);
}
function _pMap() {
_pMap = _async_to_generator(function(iterable, mapper) {
var _ref, _ref_concurrency, concurrency, _ref_stopOnError, stopOnError, signal;
var _arguments = arguments;
return _ts_generator(this, function(_state) {
_ref = _arguments.length > 2 && void 0 !== _arguments[2] ? _arguments[2] : {}, _ref_concurrency = _ref.concurrency, concurrency = void 0 === _ref_concurrency ? Number.POSITIVE_INFINITY : _ref_concurrency, _ref_stopOnError = _ref.stopOnError, stopOnError = void 0 === _ref_stopOnError ? true : _ref_stopOnError, signal = _ref.signal;
return [
2,
new Promise(function(resolve_, reject_) {
if (void 0 === iterable[Symbol.iterator] && void 0 === iterable[Symbol.asyncIterator]) throw new TypeError("Expected `input` to be either an `Iterable` or `AsyncIterable`, got (".concat(void 0 === iterable ? "undefined" : _type_of(iterable), ")"));
if ('function' != typeof mapper) throw new TypeError('Mapper function is required');
if (!(Number.isSafeInteger(concurrency) && concurrency >= 1 || concurrency === Number.POSITIVE_INFINITY)) throw new TypeError("Expected `concurrency` to be an integer from 1 and up or `Infinity`, got `".concat(concurrency, "` (").concat(void 0 === concurrency ? "undefined" : _type_of(concurrency), ")"));
var result = [];
var errors = [];
var skippedIndexesMap = new Map();
var isRejected = false;
var isResolved = false;
var isIterableDone = false;
var resolvingCount = 0;
var currentIndex = 0;
var iterator = void 0 === iterable[Symbol.iterator] ? iterable[Symbol.asyncIterator]() : iterable[Symbol.iterator]();
var signalListener = function() {
reject(signal.reason);
};
var cleanup = function() {
null == signal || signal.removeEventListener('abort', signalListener);
};
var resolve = function(value) {
resolve_(value);
cleanup();
};
var reject = function(reason) {
isRejected = true;
isResolved = true;
reject_(reason);
cleanup();
};
if (signal) {
if (signal.aborted) reject(signal.reason);
signal.addEventListener('abort', signalListener, {
once: true
});
}
var next = /*#__PURE__*/ function() {
var _ref = _async_to_generator(function() {
var nextItem, index, pureResult, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step_value, index1, value;
return _ts_generator(this, function(_state) {
switch(_state.label){
case 0:
if (isResolved) return [
2
];
return [
4,
iterator.next()
];
case 1:
nextItem = _state.sent();
index = currentIndex;
currentIndex++;
if (nextItem.done) {
isIterableDone = true;
if (0 === resolvingCount && !isResolved) {
if (!stopOnError && errors.length > 0) {
reject(new AggregateError(errors));
return [
2
];
}
isResolved = true;
if (0 === skippedIndexesMap.size) {
resolve(result);
return [
2
];
}
pureResult = [];
_iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
try {
for(_iterator = result.entries()[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
_step_value = _sliced_to_array(_step.value, 2), index1 = _step_value[0], value = _step_value[1];
if (skippedIndexesMap.get(index1) !== pMapSkip) pureResult.push(value);
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally{
try {
if (!_iteratorNormalCompletion && null != _iterator["return"]) _iterator["return"]();
} finally{
if (_didIteratorError) throw _iteratorError;
}
}
resolve(pureResult);
}
return [
2
];
}
resolvingCount++;
_async_to_generator(function() {
var element, value, error, error1;
return _ts_generator(this, function(_state) {
switch(_state.label){
case 0:
_state.trys.push([
0,
4,
,
10
]);
return [
4,
nextItem.value
];
case 1:
element = _state.sent();
if (isResolved) return [
2
];
return [
4,
mapper(element, index)
];
case 2:
value = _state.sent();
if (value === pMapSkip) skippedIndexesMap.set(index, value);
result[index] = value;
resolvingCount--;
return [
4,
next()
];
case 3:
_state.sent();
return [
3,
10
];
case 4:
error = _state.sent();
if (!stopOnError) return [
3,
5
];
reject(error);
return [
3,
9
];
case 5:
errors.push(error);
resolvingCount--;
_state.label = 6;
case 6:
_state.trys.push([
6,
8,
,
9
]);
return [
4,
next()
];
case 7:
_state.sent();
return [
3,
9
];
case 8:
error1 = _state.sent();
reject(error1);
return [
3,
9
];
case 9:
return [
3,
10
];
case 10:
return [
2
];
}
});
})();
return [
2
];
}
});
});
return function() {
return _ref.apply(this, arguments);
};
}();
_async_to_generator(function() {
var index, error;
return _ts_generator(this, function(_state) {
switch(_state.label){
case 0:
index = 0;
_state.label = 1;
case 1:
if (!(index < concurrency)) return [
3,
7
];
_state.label = 2;
case 2:
_state.trys.push([
2,
4,
,
5
]);
return [
4,
next()
];
case 3:
_state.sent();
return [
3,
5
];
case 4:
error = _state.sent();
reject(error);
return [
3,
7
];
case 5:
if (isIterableDone || isRejected) return [
3,
7
];
_state.label = 6;
case 6:
index++;
return [
3,
1
];
case 7:
return [
2
];
}
});
})();
})
];
});
});
return _pMap.apply(this, arguments);
}
var pMapSkip = Symbol('skip');
function src_rslib_entry_asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
try {
var info = gen[key](arg);
var value = info.value;
} catch (error) {
reject(error);
return;
}
if (info.done) resolve(value);
else Promise.resolve(value).then(_next, _throw);
}
function src_rslib_entry_async_to_generator(fn) {
return function() {
var self = this, args = arguments;
return new Promise(function(resolve, reject) {
var gen = fn.apply(self, args);
function _next(value) {
src_rslib_entry_asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
}
function _throw(err) {
src_rslib_entry_asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
}
_next(void 0);
});
};
}
function _check_private_redeclaration(obj, privateCollection) {
if (privateCollection.has(obj)) throw new TypeError("Cannot initialize the same private elements twice on an object");
}
function _class_apply_descriptor_get(receiver, descriptor) {
if (descriptor.get) return descriptor.get.call(receiver);
return descriptor.value;
}
function _class_apply_descriptor_set(receiver, descriptor, value) {
if (descriptor.set) descriptor.set.call(receiver, value);
else {
if (!descriptor.writable) throw new TypeError("attempted to set read only private field");
descriptor.value = value;
}
}
function _class_call_check(instance, Constructor) {
if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
}
function _class_extract_field_descriptor(receiver, privateMap, action) {
if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
return privateMap.get(receiver);
}
function _class_private_field_get(receiver, privateMap) {
var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
return _class_apply_descriptor_get(receiver, descriptor);
}
function _class_private_field_init(obj, privateMap, value) {
_check_private_redeclaration(obj, privateMap);
privateMap.set(obj, value);
}
function _class_private_field_set(receiver, privateMap, value) {
var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
_class_apply_descriptor_set(receiver, descriptor, value);
return value;
}
function _defineProperties(target, props) {
for(var i = 0; i < props.length; i++){
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
function _create_class(Constructor, protoProps, staticProps) {
if (protoProps) _defineProperties(Constructor.prototype, protoProps);
if (staticProps) _defineProperties(Constructor, staticProps);
return Constructor;
}
function src_rslib_entry_define_property(obj, key, value) {
if (key in obj) Object.defineProperty(obj, key, {
value: value,
enumerable: true,
configurable: true,
writable: true
});
else obj[key] = value;
return obj;
}
function _object_spread(target) {
for(var i = 1; i < arguments.length; i++){
var source = null != arguments[i] ? arguments[i] : {};
var ownKeys = Object.keys(source);
if ("function" == typeof Object.getOwnPropertySymbols) ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
return Object.getOwnPropertyDescriptor(source, sym).enumerable;
}));
ownKeys.forEach(function(key) {
src_rslib_entry_define_property(target, key, source[key]);
});
}
return target;
}
function src_rslib_entry_ownKeys(object, enumerableOnly) {
var keys = Object.keys(object);
if (Object.getOwnPropertySymbols) {
var symbols = Object.getOwnPropertySymbols(object);
if (enumerableOnly) symbols = symbols.filter(function(sym) {
return Object.getOwnPropertyDescriptor(object, sym).enumerable;
});
keys.push.apply(keys, symbols);
}
return keys;
}
function _object_spread_props(target, source) {
source = null != source ? source : {};
if (Object.getOwnPropertyDescriptors) Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
else src_rslib_entry_ownKeys(Object(source)).forEach(function(key) {
Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
});
return target;
}
function src_rslib_entry_ts_generator(thisArg, body) {
var f, y, t, g, _ = {
label: 0,
sent: function() {
if (1 & t[0]) throw t[1];
return t[1];
},
trys: [],
ops: []
};
return g = {
next: verb(0),
throw: verb(1),
return: verb(2)
}, "function" == typeof Symbol && (g[Symbol.iterator] = function() {
return this;
}), g;
function verb(n) {
return function(v) {
return step([
n,
v
]);
};
}
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while(_)try {
if (f = 1, y && (t = 2 & op[0] ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [
2 & op[0],
t.value
];
switch(op[0]){
case 0:
case 1:
t = op;
break;
case 4:
_.label++;
return {
value: op[1],
done: false
};
case 5:
_.label++;
y = op[1];
op = [
0
];
continue;
case 7:
op = _.ops.pop();
_.trys.pop();
continue;
default:
if (t = _.trys, !(t = t.length > 0 && t[t.length - 1]) && (6 === op[0] || 2 === op[0])) {
_ = 0;
continue;
}
if (3 === op[0] && (!t || op[1] > t[0] && op[1] < t[3])) {
_.label = op[1];
break;
}
if (6 === op[0] && _.label < t[1]) {
_.label = t[1];
t = op;
break;
}
if (t && _.label < t[2]) {
_.label = t[2];
_.ops.push(op);
break;
}
if (t[2]) _.ops.pop();
_.trys.pop();
continue;
}
op = body.call(thisArg, _);
} catch (e) {
op = [
6,
e
];
y = 0;
} finally{
f = t = 0;
}
if (5 & op[0]) throw op[1];
return {
value: op[0] ? op[1] : void 0,
done: true
};
}
}
var _options = /*#__PURE__*/ new WeakMap();
var src_rslib_entry_BabelTransformPlugin = /*#__PURE__*/ function() {
"use strict";
function BabelTransformPlugin() {
var options = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {};
_class_call_check(this, BabelTransformPlugin);
src_rslib_entry_define_property(this, "isWebpack5", false);
_class_private_field_init(this, _options, {
writable: true,
value: void 0
});
_class_private_field_set(this, _options, options || {});
}
_create_class(BabelTransformPlugin, [
{
key: "apply",
value: function(compiler) {
var webpack = compiler.webpack;
this.isWebpack5 = webpack && webpack.version.startsWith("5");
if (this.isWebpack5) this.applyWebpack5(compiler);
else this.applyWebpack4(compiler);
}
},
{
key: "applyWebpack5",
value: function(compiler) {
var _this = this;
compiler.hooks.thisCompilation.tap("BabelTransformPlugin", function(compilation) {
var _this1 = _this;
compilation.hooks.processAssets.tapPromise({
name: "BabelTransformPlugin",
stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE
}, /*#__PURE__*/ function() {
var _ref = src_rslib_entry_async_to_generator(function(assets) {
return src_rslib_entry_ts_generator(this, function(_state) {
switch(_state.label){
case 0:
return [
4,
_this1.processAllAssets(compiler, compilation, assets)
];
case 1:
_state.sent();
return [
2
];
}
});
});
return function(assets) {
return _ref.apply(this, arguments);
};
}());
});
}
},
{
key: "applyWebpack4",
value: function(compiler) {
var _this = this;
compiler.hooks.compilation.tap("BabelTransformPlugin", function(compilation) {
var _this1 = _this;
compilation.hooks.optimizeChunkAssets.tapPromise("BabelTransformPlugin", /*#__PURE__*/ function() {
var _ref = src_rslib_entry_async_to_generator(function(chunks) {
var assets;
return src_rslib_entry_ts_generator(this, function(_state) {
switch(_state.label){
case 0:
assets = {};
chunks.forEach(function(chunk) {
chunk.files.forEach(function(file) {
assets[file] = compilation.assets[file];
});
});
return [
4,
_this1.processAllAssets(compiler, compilation, assets)
];
case 1:
_state.sent();
return [
2
];
}
});
});
return function(chunks) {
return _ref.apply(this, arguments);
};
}());
});
}
},
{
key: "processAllAssets",
value: function(compiler, compilation, assets) {
var _this = this;
return src_rslib_entry_async_to_generator(function() {
var javascriptFiles, process;
return src_rslib_entry_ts_generator(this, function(_state) {
switch(_state.label){
case 0:
javascriptFiles = Object.keys(assets).filter(function(filename) {
var _class_private_field_get_filter, _$_class_private_field_get;
return filename.endsWith(".js") && (_class_private_field_get(_this, _options).filter ? null === (_class_private_field_get_filter = (_$_class_private_field_get = _class_private_field_get(_this, _options)).filter) || void 0 === _class_private_field_get_filter ? void 0 : _class_private_field_get_filter.call(_$_class_private_field_get, filename) : true);
});
process = /*#__PURE__*/ function() {
var _ref = src_rslib_entry_async_to_generator(function(filename) {
var originalSource, sourceStr, modifiedSource;
return src_rslib_entry_ts_generator(this, function(_state) {
switch(_state.label){
case 0:
originalSource = assets[filename].source();
sourceStr = "string" == typeof originalSource ? originalSource : originalSource.toString();
return [
4,
_this.replaceContent(compiler, sourceStr, filename)
];
case 1:
modifiedSource = _state.sent();
if (modifiedSource === sourceStr) return [
2
];
if (_this.isWebpack5) compilation.updateAsset(filename, new compiler.webpack.sources.RawSource(modifiedSource));
else compilation.assets[filename] = {
source: function() {
return modifiedSource;
},
size: function() {
return modifiedSource.length;
}
};
return [
2
];
}
});
});
return function(filename) {
return _ref.apply(this, arguments);
};
}();
return [
4,
pMap(javascriptFiles, process, {
concurrency: __WEBPACK_EXTERNAL_MODULE_os__["default"].cpus().length
})
];
case 1:
_state.sent();
return [
2
];
}
});
})();
}
},
{
key: "replaceContent",
value: function(compiler, source, filename) {
var _this = this;
return src_rslib_entry_async_to_generator(function() {
var _class_private_field_get_transformOptions, result;
return src_rslib_entry_ts_generator(this, function(_state) {
switch(_state.label){
case 0:
return [
4,
(0, __WEBPACK_EXTERNAL_MODULE__babel_core_1832d21b__.transformAsync)(source, _object_spread_props(_object_spread({
comments: "production" !== compiler.options.mode,
configFile: false,
babelrc: false,
browserslistConfigFile: false
}, null !== (_class_private_field_get_transformOptions = _class_private_field_get(_this, _options).transformOptions) && void 0 !== _class_private_field_get_transformOptions ? _class_private_field_get_transformOptions : {}), {
filename: filename,
ast: false,
cloneInputAst: false,
ignore: void 0,
include: void 0,
exclude: void 0
}))
];
case 1:
result = _state.sent();
if (!(null == result ? void 0 : result.code)) throw new Error("Babel transform failed");
return [
2,
result.code
];
}
});
})();
}
}
]);
return BabelTransformPlugin;
}();
var src_rslib_entry_ = src_rslib_entry_BabelTransformPlugin;
export { src_rslib_entry_BabelTransformPlugin as BabelTransformPlugin, src_rslib_entry_ as default };
//# sourceMappingURL=index.mjs.map