@parcel/optimizer-terser 2.0.0-nightly.92 → 2.0.1

package/lib/TerserOptimizer.js

@@ -5,99 +5,214 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _nullthrows = _interopRequireDefault(require("nullthrows"));
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
 
-var _terser = require("terser");
+  _nullthrows = function () {
+    return data;
+  };
 
-var _plugin = require("@parcel/plugin");
+  return data;
+}
 
-var _utils = require("@parcel/utils");
+function _terser() {
+  const data = require("terser");
 
-var _sourceMap = _interopRequireDefault(require("@parcel/source-map"));
+  _terser = function () {
+    return data;
+  };
 
-var _path = _interopRequireDefault(require("path"));
+  return data;
+}
+
+function _plugin() {
+  const data = require("@parcel/plugin");
+
+  _plugin = function () {
+    return data;
+  };
+
+  return data;
+}
+
+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 _diagnostic() {
+  const data = _interopRequireWildcard(require("@parcel/diagnostic"));
+
+  _diagnostic = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+
+  _path = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+
+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 }; }
 
-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; }
+var _default = new (_plugin().Optimizer)({
+  async loadConfig({
+    config,
+    options
+  }) {
+    let userConfig = await config.getConfigFrom(_path().default.join(options.projectRoot, 'index'), ['.terserrc', '.terserrc.js']);
 
-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; }
+    if (userConfig) {
+      let isJavascript = _path().default.extname(userConfig.filePath) === '.js';
 
-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; }
+      if (isJavascript) {
+        config.invalidateOnStartup();
+      }
+    }
+
+    return userConfig === null || userConfig === void 0 ? void 0 : userConfig.contents;
+  },
 
-var _default = new _plugin.Optimizer({
   async optimize({
     contents,
     map,
     bundle,
-    options
+    config: userConfig,
+    options,
+    getSourceMapReference
   }) {
-    var _userConfig$config;
-
-    if (!options.minify) {
+    if (!bundle.env.shouldOptimize) {
       return {
         contents,
         map
       };
     }
 
-    if (typeof contents !== 'string') {
-      throw new Error('TerserOptimizer: Only string contents are currently supported');
-    }
-
-    let userConfig = await (0, _utils.loadConfig)(options.inputFS, _path.default.join(options.projectRoot, 'index'), ['.terserrc', '.uglifyrc', '.uglifyrc.js', '.terserrc.js']);
-
-    let config = _objectSpread({
-      warnings: true
-    }, userConfig === null || userConfig === void 0 ? void 0 : userConfig.config, {
-      compress: _objectSpread({}, userConfig === null || userConfig === void 0 ? void 0 : (_userConfig$config = userConfig.config) === null || _userConfig$config === void 0 ? void 0 : _userConfig$config.compress, {
-        toplevel: bundle.env.outputFormat === 'esmodule' || bundle.env.outputFormat === 'commonjs'
-      }),
-      sourceMap: {
-        filename: _path.default.relative(options.projectRoot, bundle.filePath)
-      },
+    let code = await (0, _utils().blobToString)(contents);
+    let originalMap = map ? await map.stringify({}) : null;
+    let config = { ...userConfig,
+      sourceMap: bundle.env.sourceMap ? {
+        filename: _path().default.relative(options.projectRoot, _path().default.join(bundle.target.distDir, bundle.name)),
+        asObject: true,
+        content: originalMap
+      } : false,
+      toplevel: bundle.env.outputFormat === 'esmodule' || bundle.env.outputFormat === 'commonjs',
       module: bundle.env.outputFormat === 'esmodule'
-    });
-
-    let sourceMap = null;
-
-    if (options.sourceMaps) {
-      sourceMap = new _sourceMap.default(); // $FlowFixMe
-
-      config.output = {
-        source_map: {
-          add(source, gen_line, gen_col, orig_line, orig_col, name) {
-            // $FlowFixMe
-            sourceMap.addMapping({
-              source,
-              name,
-              original: {
-                line: orig_line,
-                column: orig_col
-              },
-              generated: {
-                line: gen_line,
-                column: gen_col
-              }
-            });
-          }
+    };
+    let result;
+
+    try {
+      result = await (0, _terser().minify)(code, config);
+    } catch (error) {
+      // $FlowFixMe
+      let {
+        message,
+        line,
+        col
+      } = error;
+
+      if (line != null && col != null) {
+        message = (0, _diagnostic().escapeMarkdown)(message);
+        let diagnostics = [];
+        let mapping = map === null || map === void 0 ? void 0 : map.findClosestMapping(line, col);
+
+        if (mapping && mapping.original && mapping.source) {
+          let {
+            source,
+            original
+          } = mapping;
+
+          let filePath = _path().default.resolve(options.projectRoot, source);
+
+          diagnostics.push({
+            message,
+            origin: '@parcel/optimizer-terser',
+            codeFrames: [{
+              language: 'js',
+              filePath,
+              code: await options.inputFS.readFile(filePath, 'utf8'),
+              codeHighlights: [{
+                message,
+                start: original,
+                end: original
+              }]
+            }],
+            hints: ["It's likely that Terser doesn't support this syntax yet."]
+          });
+        }
 
+        if (diagnostics.length === 0 || options.logLevel === 'verbose') {
+          let loc = {
+            line: line,
+            column: col
+          };
+          diagnostics.push({
+            message,
+            origin: '@parcel/optimizer-terser',
+            codeFrames: [{
+              language: 'js',
+              filePath: undefined,
+              code,
+              codeHighlights: [{
+                message,
+                start: loc,
+                end: loc
+              }]
+            }],
+            hints: ["It's likely that Terser doesn't support this syntax yet."]
+          });
         }
-      };
-    }
 
-    if (sourceMap && map) {
-      sourceMap = await map.extend(sourceMap);
+        throw new (_diagnostic().default)({
+          diagnostic: diagnostics
+        });
+      } else {
+        throw error;
+      }
     }
 
-    let result = (0, _terser.minify)(contents, config);
+    let sourceMap = null;
+    let minifiedContents = (0, _nullthrows().default)(result.code);
+    let resultMap = result.map;
+
+    if (resultMap && typeof resultMap !== 'string') {
+      sourceMap = new (_sourceMap().default)(options.projectRoot);
+      sourceMap.addVLQMap(resultMap);
+      let sourcemapReference = await getSourceMapReference(sourceMap);
 
-    if (result.error) {
-      throw result.error;
+      if (sourcemapReference) {
+        minifiedContents += `\n//# sourceMappingURL=${sourcemapReference}\n`;
+      }
     }
 
     return {
-      contents: (0, _nullthrows.default)(result.code),
+      contents: minifiedContents,
       map: sourceMap
     };
   }

package/package.json

@@ -1,10 +1,14 @@
 {
   "name": "@parcel/optimizer-terser",
-  "version": "2.0.0-nightly.92+c0655c56",
+  "version": "2.0.1",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
   },
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/parcel"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/parcel-bundler/parcel.git"
@@ -12,15 +16,16 @@
   "main": "lib/TerserOptimizer.js",
   "source": "src/TerserOptimizer.js",
   "engines": {
-    "node": ">= 10.0.0",
-    "parcel": "^2.0.0-alpha.1.1"
+    "node": ">= 12.0.0",
+    "parcel": "^2.0.1"
   },
   "dependencies": {
-    "@parcel/plugin": "2.0.0-nightly.92+c0655c56",
-    "@parcel/source-map": "2.0.0-nightly.92+c0655c56",
-    "@parcel/utils": "2.0.0-nightly.92+c0655c56",
+    "@parcel/diagnostic": "^2.0.1",
+    "@parcel/plugin": "^2.0.1",
+    "@parcel/source-map": "^2.0.0",
+    "@parcel/utils": "^2.0.1",
     "nullthrows": "^1.1.1",
-    "terser": "^4.0.0"
+    "terser": "^5.2.0"
   },
-  "gitHead": "c0655c56f7973492fdb28671029ddd923f17a244"
+  "gitHead": "28b47e6bdca7de2a06b7cc39a4a0b1df89f3fe15"
 }

package/src/TerserOptimizer.js

@@ -3,78 +3,126 @@
 import nullthrows from 'nullthrows';
 import {minify} from 'terser';
 import {Optimizer} from '@parcel/plugin';
-import {loadConfig} from '@parcel/utils';
+import {blobToString} from '@parcel/utils';
 import SourceMap from '@parcel/source-map';
+import ThrowableDiagnostic, {escapeMarkdown} from '@parcel/diagnostic';
+
 import path from 'path';
 
-export default new Optimizer({
-  async optimize({contents, map, bundle, options}) {
-    if (!options.minify) {
-      return {contents, map};
+export default (new Optimizer({
+  async loadConfig({config, options}) {
+    let userConfig = await config.getConfigFrom(
+      path.join(options.projectRoot, 'index'),
+      ['.terserrc', '.terserrc.js'],
+    );
+
+    if (userConfig) {
+      let isJavascript = path.extname(userConfig.filePath) === '.js';
+      if (isJavascript) {
+        config.invalidateOnStartup();
+      }
     }
 
-    if (typeof contents !== 'string') {
-      throw new Error(
-        'TerserOptimizer: Only string contents are currently supported',
-      );
+    return userConfig?.contents;
+  },
+  async optimize({
+    contents,
+    map,
+    bundle,
+    config: userConfig,
+    options,
+    getSourceMapReference,
+  }) {
+    if (!bundle.env.shouldOptimize) {
+      return {contents, map};
     }
 
-    let userConfig = await loadConfig(
-      options.inputFS,
-      path.join(options.projectRoot, 'index'),
-      ['.terserrc', '.uglifyrc', '.uglifyrc.js', '.terserrc.js'],
-    );
+    let code = await blobToString(contents);
 
+    let originalMap = map ? await map.stringify({}) : null;
     let config = {
-      warnings: true,
-      ...userConfig?.config,
-      compress: {
-        ...userConfig?.config?.compress,
-        toplevel:
-          bundle.env.outputFormat === 'esmodule' ||
-          bundle.env.outputFormat === 'commonjs',
-      },
-      sourceMap: {
-        filename: path.relative(options.projectRoot, bundle.filePath),
-      },
+      ...userConfig,
+      sourceMap: bundle.env.sourceMap
+        ? {
+            filename: path.relative(
+              options.projectRoot,
+              path.join(bundle.target.distDir, bundle.name),
+            ),
+            asObject: true,
+            content: originalMap,
+          }
+        : false,
+      toplevel:
+        bundle.env.outputFormat === 'esmodule' ||
+        bundle.env.outputFormat === 'commonjs',
       module: bundle.env.outputFormat === 'esmodule',
     };
 
-    let sourceMap = null;
-    if (options.sourceMaps) {
-      sourceMap = new SourceMap();
+    let result;
+    try {
+      result = await minify(code, config);
+    } catch (error) {
       // $FlowFixMe
-      config.output = {
-        source_map: {
-          add(source, gen_line, gen_col, orig_line, orig_col, name) {
-            // $FlowFixMe
-            sourceMap.addMapping({
-              source,
-              name,
-              original: {
-                line: orig_line,
-                column: orig_col,
+      let {message, line, col} = error;
+      if (line != null && col != null) {
+        message = escapeMarkdown(message);
+        let diagnostics = [];
+        let mapping = map?.findClosestMapping(line, col);
+        if (mapping && mapping.original && mapping.source) {
+          let {source, original} = mapping;
+          let filePath = path.resolve(options.projectRoot, source);
+          diagnostics.push({
+            message,
+            origin: '@parcel/optimizer-terser',
+            codeFrames: [
+              {
+                language: 'js',
+                filePath,
+                code: await options.inputFS.readFile(filePath, 'utf8'),
+                codeHighlights: [{message, start: original, end: original}],
               },
-              generated: {
-                line: gen_line,
-                column: gen_col,
-              },
-            });
-          },
-        },
-      };
-    }
+            ],
+            hints: ["It's likely that Terser doesn't support this syntax yet."],
+          });
+        }
 
-    if (sourceMap && map) {
-      sourceMap = await map.extend(sourceMap);
+        if (diagnostics.length === 0 || options.logLevel === 'verbose') {
+          let loc = {
+            line: line,
+            column: col,
+          };
+          diagnostics.push({
+            message,
+            origin: '@parcel/optimizer-terser',
+            codeFrames: [
+              {
+                language: 'js',
+                filePath: undefined,
+                code,
+                codeHighlights: [{message, start: loc, end: loc}],
+              },
+            ],
+            hints: ["It's likely that Terser doesn't support this syntax yet."],
+          });
+        }
+        throw new ThrowableDiagnostic({diagnostic: diagnostics});
+      } else {
+        throw error;
+      }
     }
 
-    let result = minify(contents, config);
-
-    if (result.error) {
-      throw result.error;
+    let sourceMap = null;
+    let minifiedContents: string = nullthrows(result.code);
+    let resultMap = result.map;
+    if (resultMap && typeof resultMap !== 'string') {
+      sourceMap = new SourceMap(options.projectRoot);
+      sourceMap.addVLQMap(resultMap);
+      let sourcemapReference = await getSourceMapReference(sourceMap);
+      if (sourcemapReference) {
+        minifiedContents += `\n//# sourceMappingURL=${sourcemapReference}\n`;
+      }
     }
 
-    return {contents: nullthrows(result.code), map: sourceMap};
+    return {contents: minifiedContents, map: sourceMap};
   },
-});
+}): Optimizer);