@parcel/transformer-babel 2.0.0-nightly.92 → 2.0.1

package/lib/BabelTransformer.js

@@ -5,50 +5,85 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _plugin = require("@parcel/plugin");
+function _babelAstUtils() {
+  const data = require("@parcel/babel-ast-utils");
 
-var _sourceMap = _interopRequireDefault(require("@parcel/source-map"));
+  _babelAstUtils = function () {
+    return data;
+  };
 
-var _generator = _interopRequireDefault(require("@babel/generator"));
+  return data;
+}
 
-var _semver = _interopRequireDefault(require("semver"));
+function _plugin() {
+  const data = require("@parcel/plugin");
 
-var _babel = _interopRequireDefault(require("./babel7"));
+  _plugin = function () {
+    return data;
+  };
 
-var _utils = require("@parcel/utils");
+  return data;
+}
 
-var _config = require("./config");
+function _utils() {
+  const data = require("@parcel/utils");
+
+  _utils = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _sourceMap() {
+  const data = _interopRequireDefault(require("@parcel/source-map"));
+
+  _sourceMap = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _semver() {
+  const data = _interopRequireDefault(require("semver"));
 
-var _babelErrorUtils = require("./babelErrorUtils");
+  _semver = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _generator() {
+  const data = _interopRequireDefault(require("@babel/generator"));
+
+  _generator = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _babel = _interopRequireDefault(require("./babel7"));
+
+var _config = require("./config");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-var _default = new _plugin.Transformer({
-  async loadConfig({
+var _default = new (_plugin().Transformer)({
+  loadConfig({
     config,
     options,
     logger
   }) {
-    await (0, _config.load)(config, options, logger);
-  },
-
-  preSerializeConfig({
-    config
-  }) {
-    return (0, _config.preSerialize)(config);
-  },
-
-  postDeserializeConfig({
-    config,
-    options
-  }) {
-    return (0, _config.postDeserialize)(config, options);
+    return (0, _config.load)(config, options, logger);
   },
 
   canReuseAST({
     ast
   }) {
-    return ast.type === 'babel' && _semver.default.satisfies(ast.version, '^7.0.0');
+    return ast.type === 'babel' && _semver().default.satisfies(ast.version, '^7.0.0');
   },
 
   async transform({
@@ -56,44 +91,69 @@ var _default = new _plugin.Transformer({
     config,
     options
   }) {
-    // TODO: come up with a better name
     try {
-      if (config === null || config === void 0 ? void 0 : config.config) {
-        if (asset.meta.babelPlugins && Array.isArray(asset.meta.babelPlugins)) {
-          // $FlowFixMe
-          asset.ast = await (0, _babel.default)(asset, options, config, asset.meta.babelPlugins);
+      if (config !== null && config !== void 0 && config.config) {
+        if (asset.meta.babelPlugins != null && Array.isArray(asset.meta.babelPlugins)) {
+          await (0, _babel.default)({
+            asset,
+            options,
+            babelOptions: config,
+            additionalPlugins: asset.meta.babelPlugins
+          });
         } else {
-          asset.ast = await (0, _babel.default)(asset, options, config);
+          await (0, _babel.default)({
+            asset,
+            options,
+            babelOptions: config
+          });
         }
       }
 
       return [asset];
     } catch (e) {
-      throw await (0, _babelErrorUtils.babelErrorEnhancer)(e, asset);
+      throw await (0, _babelAstUtils().babelErrorEnhancer)(e, asset);
     }
   },
 
   async generate({
     asset,
+    ast,
     options
   }) {
-    let sourceFileName = (0, _utils.relativeUrl)(options.projectRoot, asset.filePath);
+    let originalSourceMap = await asset.getMap();
+    let sourceFileName = (0, _utils().relativeUrl)(options.projectRoot, asset.filePath);
+    let {
+      code,
+      rawMappings
+    } = (0, _generator().default)(ast.program, {
+      sourceFileName,
+      sourceMaps: !!asset.env.sourceMap,
+      comments: true
+    });
+    let map = new (_sourceMap().default)(options.projectRoot);
+
+    if (rawMappings) {
+      map.addIndexedMappings(rawMappings);
+    }
 
-    try {
-      // $FlowFixMe: figure out how to make AST required in generate method
-      let generated = (0, _generator.default)(asset.ast.program, {
-        sourceMaps: options.sourceMaps,
-        sourceFileName: sourceFileName
-      });
-      return {
-        code: generated.code,
-        map: new _sourceMap.default(generated.rawMappings, {
-          [sourceFileName]: null
-        })
-      };
-    } catch (e) {
-      throw await (0, _babelErrorUtils.babelErrorEnhancer)(e, asset);
+    if (originalSourceMap) {
+      // The babel AST already contains the correct mappings, but not the source contents.
+      // We need to copy over the source contents from the original map.
+      let sourcesContent = originalSourceMap.getSourcesContentMap();
+
+      for (let filePath in sourcesContent) {
+        let content = sourcesContent[filePath];
+
+        if (content != null) {
+          map.setSourceContent(filePath, content);
+        }
+      }
     }
+
+    return {
+      content: code,
+      map
+    };
   }
 
 });

package/lib/astConverter.js

@@ -6,7 +6,15 @@ Object.defineProperty(exports, "__esModule", {
 exports.babel7toBabel6 = babel7toBabel6;
 exports.babel6toBabel7 = babel6toBabel7;
 
-var _traverse = _interopRequireDefault(require("@babel/traverse"));
+function _traverse() {
+  const data = _interopRequireDefault(require("@babel/traverse"));
+
+  _traverse = function () {
+    return data;
+  };
+
+  return data;
+}
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
@@ -42,7 +50,7 @@ function babel7toBabel6(ast) {
       }
     }
   };
-  (0, _traverse.default)(ast, {
+  (0, _traverse().default)(ast, {
     enter(path) {
       if (path.node.variance && path.node.variance.type === 'Variance') {
         path.node.variance = path.node.variance.kind;
@@ -85,7 +93,7 @@ function babel6toBabel7(ast) {
       node.type = 'RestElement';
     }
   };
-  (0, _traverse.default)(ast, {
+  (0, _traverse().default)(ast, {
     enter(path) {
       if (path.node.variance && typeof path.node.variance === 'string') {
         path.node.variance = {

package/lib/babel7.js

@@ -5,61 +5,116 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = babel7;
 
-var _package = _interopRequireDefault(require("../package.json"));
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
 
-var _assert = _interopRequireDefault(require("assert"));
+  _assert = function () {
+    return data;
+  };
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+  return data;
+}
+
+function internalBabelCore() {
+  const data = _interopRequireWildcard(require("@babel/core"));
+
+  internalBabelCore = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _utils() {
+  const data = require("@parcel/utils");
+
+  _utils = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _babelAstUtils() {
+  const data = require("@parcel/babel-ast-utils");
+
+  _babelAstUtils = function () {
+    return data;
+  };
 
-function 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; }
+  return data;
+}
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+var _package = _interopRequireDefault(require("../package.json"));
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
 
-function _defineProperty(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 _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 const transformerVersion = _package.default.version;
-(0, _assert.default)(typeof transformerVersion === 'string');
+(0, _assert().default)(typeof transformerVersion === 'string');
 
-async function babel7(asset, options, babelOptions, additionalPlugins = []) {
-  // If this is an internally generated config, use our internal @babel/core,
-  // otherwise require a local version from the package we're compiling.
-  let babel = babelOptions.internal ? require('@babel/core') : await options.packageManager.require('@babel/core', asset.filePath);
+async function babel7(opts) {
+  var _babelOptions$config$, _babelOptions$config$2, _babelOptions$syntaxP;
 
-  let config = _objectSpread({}, babelOptions.config, {
+  let {
+    asset,
+    options,
+    babelOptions,
+    additionalPlugins = []
+  } = opts;
+  const babelCore = babelOptions.internal ? internalBabelCore() : await options.packageManager.require('@babel/core', asset.filePath, {
+    range: '^7.12.0',
+    saveDev: true,
+    shouldAutoInstall: options.shouldAutoInstall
+  });
+  let config = { ...babelOptions.config,
     plugins: additionalPlugins.concat(babelOptions.config.plugins),
     code: false,
     ast: true,
     filename: asset.filePath,
     babelrc: false,
     configFile: false,
-    parserOpts: _objectSpread({}, babelOptions.config.parserOpts, {
+    parserOpts: { ...babelOptions.config.parserOpts,
+      sourceFilename: (0, _utils().relativeUrl)(options.projectRoot, asset.filePath),
       allowReturnOutsideFunction: true,
       strictMode: false,
       sourceType: 'module',
-      plugins: ['dynamicImport']
-    }),
+      plugins: [...((_babelOptions$config$ = (_babelOptions$config$2 = babelOptions.config.parserOpts) === null || _babelOptions$config$2 === void 0 ? void 0 : _babelOptions$config$2.plugins) !== null && _babelOptions$config$ !== void 0 ? _babelOptions$config$ : []), ...((_babelOptions$syntaxP = babelOptions.syntaxPlugins) !== null && _babelOptions$syntaxP !== void 0 ? _babelOptions$syntaxP : []), // Applied by preset-env
+      'classProperties', 'classPrivateProperties', 'classPrivateMethods', 'exportDefaultFrom' // 'topLevelAwait'
+      ]
+    },
     caller: {
       name: 'parcel',
       version: transformerVersion,
-      targets: JSON.stringify(babelOptions.targets)
+      targets: JSON.stringify(babelOptions.targets),
+      outputFormat: asset.env.outputFormat
     }
-  });
-
-  let code = await asset.getCode();
+  };
+  let ast = await asset.getAST();
   let res;
 
-  if (asset.ast) {
-    res = babel.transformFromAstSync(asset.ast.program, code, config);
+  if (ast) {
+    res = await babelCore.transformFromAstAsync(ast.program, asset.isASTDirty() ? undefined : await asset.getCode(), config);
   } else {
-    res = babel.transformSync(code, config);
+    res = await babelCore.transformAsync(await asset.getCode(), config);
+
+    if (res.ast) {
+      let map = await asset.getMap();
+
+      if (map) {
+        (0, _babelAstUtils().remapAstLocations)(res.ast, map);
+      }
+    }
   }
 
   if (res.ast) {
-    return {
+    asset.setAST({
       type: 'babel',
       version: '7.0.0',
-      program: res.ast,
-      isDirty: true
-    };
+      program: res.ast
+    });
   }
 }