@parcel/transformer-babel 2.0.0-nightly.130 → 2.0.0-nightly.1303

package/lib/BabelTransformer.js

@@ -5,65 +5,95 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _plugin = require("@parcel/plugin");
+var _babelErrorUtils = require("./babelErrorUtils");
 
-var _sourceMap = _interopRequireDefault(require("@parcel/source-map"));
+function _plugin() {
+  const data = require("@parcel/plugin");
 
-var _generator = _interopRequireDefault(require("@babel/generator"));
+  _plugin = function () {
+    return data;
+  };
 
-var _semver = _interopRequireDefault(require("semver"));
+  return data;
+}
 
-var _babel = _interopRequireDefault(require("./babel7"));
+function _utils() {
+  const data = require("@parcel/utils");
 
-var _utils = require("@parcel/utils");
+  _utils = function () {
+    return data;
+  };
 
-var _config = require("./config");
+  return data;
+}
 
-var _babelErrorUtils = require("./babelErrorUtils");
+function _sourceMap() {
+  const data = _interopRequireDefault(require("@parcel/source-map"));
+
+  _sourceMap = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _semver() {
+  const data = _interopRequireDefault(require("semver"));
+
+  _semver = 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({
     asset,
     config,
-    options
+    logger,
+    options,
+    tracer
   }) {
-    // 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,
+            logger,
+            babelOptions: config,
+            additionalPlugins: asset.meta.babelPlugins,
+            tracer
+          });
         } else {
-          asset.ast = await (0, _babel.default)(asset, options, config);
+          await (0, _babel.default)({
+            asset,
+            options,
+            logger,
+            babelOptions: config,
+            tracer
+          });
         }
       }
 
@@ -75,25 +105,51 @@ var _default = new _plugin.Transformer({
 
   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);
+    const babelCorePath = await options.packageManager.resolve('@babel/core', asset.filePath, {
+      range: '^7.12.0',
+      saveDev: true,
+      shouldAutoInstall: options.shouldAutoInstall
+    });
+    const {
+      default: generate
+    } = await options.packageManager.require('@babel/generator', babelCorePath.resolved);
+    let {
+      code,
+      rawMappings
+    } = generate(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/babel7.js

@@ -5,65 +5,151 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = babel7;
 
-var _assert = _interopRequireDefault(require("assert"));
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
 
-var _constants = require("./constants");
+  _assert = function () {
+    return data;
+  };
 
-var _package = _interopRequireDefault(require("../package.json"));
+  return data;
+}
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+
+  _path = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _diagnostic() {
+  const data = require("@parcel/diagnostic");
+
+  _diagnostic = function () {
+    return data;
+  };
+
+  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; }
+function _utils() {
+  const data = require("@parcel/utils");
 
-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; }
+  _utils = function () {
+    return data;
+  };
 
-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; }
+  return data;
+}
+
+var _remapAstLocations = require("./remapAstLocations");
+
+var _package = _interopRequireDefault(require("../package.json"));
+
+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, {
-    range: _constants.BABEL_RANGE
-  });
+async function babel7(opts) {
+  var _babelOptions$config$, _babelOptions$config$2, _babelOptions$syntaxP;
 
-  let config = _objectSpread({}, babelOptions.config, {
+  let {
+    asset,
+    options,
+    babelOptions,
+    additionalPlugins = [],
+    tracer
+  } = opts;
+  const babelCore = 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
     }
-  });
+  };
+
+  if (tracer.enabled) {
+    config.wrapPluginVisitorMethod = (key, nodeType, fn) => {
+      return function () {
+        let pluginKey = key;
+
+        if (pluginKey.startsWith(options.projectRoot)) {
+          pluginKey = _path().default.relative(options.projectRoot, pluginKey);
+        }
+
+        const measurement = tracer.createMeasurement(pluginKey, nodeType, _path().default.relative(options.projectRoot, asset.filePath));
+        fn.apply(this, arguments);
+        measurement && measurement.end();
+      };
+    };
+  }
 
-  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, _remapAstLocations.remapAstLocations)(babelCore.types, res.ast, map);
+      }
+    }
+
+    if (res.externalDependencies) {
+      for (let f of res.externalDependencies) {
+        if (!_path().default.isAbsolute(f)) {
+          opts.logger.warn({
+            message: (0, _diagnostic().md)`Ignoring non-absolute Babel external dependency: ${f}`,
+            hints: ['Please report this to the corresponding Babel plugin and/or to Parcel.']
+          });
+        } else {
+          if (await options.inputFS.exists(f)) {
+            asset.invalidateOnFileChange(f);
+          } else {
+            asset.invalidateOnFileCreate({
+              filePath: f
+            });
+          }
+        }
+      }
+    }
   }
 
   if (res.ast) {
-    return {
+    asset.setAST({
       type: 'babel',
       version: '7.0.0',
-      program: res.ast,
-      isDirty: true
-    };
+      program: res.ast
+    });
   }
 }

package/lib/babelErrorUtils.js

@@ -7,7 +7,8 @@ exports.babelErrorEnhancer = babelErrorEnhancer;
 
 async function babelErrorEnhancer(error, asset) {
   if (error.loc) {
-    error.message = error.message.slice(asset.filePath.length + 1, error.message.indexOf('\n')).trim();
+    let start = error.message.startsWith(asset.filePath) ? asset.filePath.length + 1 : 0;
+    error.message = error.message.slice(start).split('\n')[0].trim();
   }
 
   error.source = await asset.getCode();