@parcel/utils 2.0.0-nightly.97 → 2.0.0-nightly.982

package/lib/dependency-location.js

@@ -5,17 +5,17 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = createDependencyLocation;
 
-function createDependencyLocation(start, moduleSpecifier, lineOffset = 0, columnOffset = 0, // Imports are usually wrapped in quotes
+function createDependencyLocation(start, specifier, lineOffset = 0, columnOffset = 0, // Imports are usually wrapped in quotes
 importWrapperLength = 2) {
   return {
-    filePath: moduleSpecifier,
+    filePath: specifier,
     start: {
       line: start.line + lineOffset,
       column: start.column + columnOffset
     },
     end: {
       line: start.line + lineOffset,
-      column: start.column + moduleSpecifier.length - 1 + importWrapperLength + columnOffset
+      column: start.column + specifier.length - 1 + importWrapperLength + columnOffset
     }
   };
 }

package/lib/generateBuildMetrics.js

@@ -0,0 +1,148 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = generateBuildMetrics;
+
+function _sourceMap() {
+  const data = _interopRequireDefault(require("@parcel/source-map"));
+
+  _sourceMap = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+
+  _nullthrows = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+
+  _path = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _ = require("./");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+async function getSourcemapSizes(filePath, fs, projectRoot) {
+  let bundleContents = await fs.readFile(filePath, 'utf-8');
+  let mapUrlData = await (0, _.loadSourceMapUrl)(fs, filePath, bundleContents);
+
+  if (!mapUrlData) {
+    return null;
+  }
+
+  let rawMap = mapUrlData.map;
+  let sourceMap = new (_sourceMap().default)(projectRoot);
+  sourceMap.addVLQMap(rawMap);
+  let parsedMapData = sourceMap.getMap();
+
+  if (parsedMapData.mappings.length > 2) {
+    let sources = parsedMapData.sources.map(s => _path().default.normalize(_path().default.join(projectRoot, s)));
+    let currLine = 1;
+    let currColumn = 0;
+    let currMappingIndex = 0;
+    let currMapping = parsedMapData.mappings[currMappingIndex];
+    let nextMapping = parsedMapData.mappings[currMappingIndex + 1];
+    let sourceSizes = new Array(sources.length).fill(0);
+    let unknownOrigin = 0;
+
+    for (let i = 0; i < bundleContents.length; i++) {
+      let character = bundleContents[i];
+
+      while (nextMapping && nextMapping.generated.line === currLine && nextMapping.generated.column <= currColumn) {
+        currMappingIndex++;
+        currMapping = parsedMapData.mappings[currMappingIndex];
+        nextMapping = parsedMapData.mappings[currMappingIndex + 1];
+      }
+
+      let currentSource = currMapping.source;
+      let charSize = Buffer.byteLength(character, 'utf8');
+
+      if (currentSource != null && currMapping.generated.line === currLine && currMapping.generated.column <= currColumn) {
+        sourceSizes[currentSource] += charSize;
+      } else {
+        unknownOrigin += charSize;
+      }
+
+      if (character === '\n') {
+        currColumn = 0;
+        currLine++;
+      } else {
+        currColumn++;
+      }
+    }
+
+    let sizeMap = new Map();
+
+    for (let i = 0; i < sourceSizes.length; i++) {
+      sizeMap.set(sources[i], sourceSizes[i]);
+    }
+
+    sizeMap.set('', unknownOrigin);
+    return sizeMap;
+  }
+}
+
+async function createBundleStats(bundle, fs, projectRoot) {
+  let filePath = bundle.filePath;
+  let sourcemapSizes = await getSourcemapSizes(filePath, fs, projectRoot);
+  let assets = new Map();
+  bundle.traverseAssets(asset => {
+    let filePath = _path().default.normalize(asset.filePath);
+
+    assets.set(filePath, {
+      filePath,
+      size: asset.stats.size,
+      originalSize: asset.stats.size,
+      time: asset.stats.time
+    });
+  });
+  let assetsReport = [];
+
+  if (sourcemapSizes && sourcemapSizes.size) {
+    assetsReport = Array.from(sourcemapSizes.keys()).map(filePath => {
+      let foundSize = sourcemapSizes.get(filePath) || 0;
+      let stats = assets.get(filePath) || {
+        filePath,
+        size: foundSize,
+        originalSize: foundSize,
+        time: 0
+      };
+      return { ...stats,
+        size: foundSize
+      };
+    });
+  } else {
+    assetsReport = Array.from(assets.values());
+  }
+
+  return {
+    filePath: (0, _nullthrows().default)(bundle.filePath),
+    size: bundle.stats.size,
+    time: bundle.stats.time,
+    assets: assetsReport.sort((a, b) => b.size - a.size)
+  };
+}
+
+async function generateBuildMetrics(bundles, fs, projectRoot) {
+  bundles.sort((a, b) => b.stats.size - a.stats.size).filter(b => !!b.filePath);
+  return {
+    bundles: (await Promise.all(bundles.map(b => createBundleStats(b, fs, projectRoot)))).filter(e => !!e)
+  };
+}

package/lib/generateCertificate.js

@@ -5,20 +5,44 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = generateCertificate;
 
-var _nodeForge = _interopRequireDefault(require("node-forge"));
+function _nodeForge() {
+  const data = _interopRequireDefault(require("node-forge"));
 
-var _path = _interopRequireDefault(require("path"));
+  _nodeForge = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+
+  _path = function () {
+    return data;
+  };
 
-var _logger = _interopRequireDefault(require("@parcel/logger"));
+  return data;
+}
+
+function _logger() {
+  const data = _interopRequireDefault(require("@parcel/logger"));
+
+  _logger = function () {
+    return data;
+  };
+
+  return data;
+}
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 async function generateCertificate(fs, cacheDir, host) {
   let certDirectory = cacheDir;
 
-  const privateKeyPath = _path.default.join(certDirectory, 'private.pem');
+  const privateKeyPath = _path().default.join(certDirectory, 'private.pem');
 
-  const certPath = _path.default.join(certDirectory, 'primary.crt');
+  const certPath = _path().default.join(certDirectory, 'primary.crt');
 
   const cachedKey = (await fs.exists(privateKeyPath)) && (await fs.readFile(privateKeyPath));
   const cachedCert = (await fs.exists(certPath)) && (await fs.readFile(certPath));
@@ -30,9 +54,10 @@ async function generateCertificate(fs, cacheDir, host) {
     };
   }
 
-  _logger.default.progress('Generating SSL Certificate...');
+  _logger().default.progress('Generating SSL Certificate...');
+
+  const pki = _nodeForge().default.pki;
 
-  const pki = _nodeForge.default.pki;
   const keys = pki.rsa.generateKeyPair(2048);
   const cert = pki.createCertificate();
   cert.publicKey = keys.publicKey;
@@ -111,7 +136,7 @@ async function generateCertificate(fs, cacheDir, host) {
   }, {
     name: 'subjectKeyIdentifier'
   }]);
-  cert.sign(keys.privateKey, _nodeForge.default.md.sha256.create());
+  cert.sign(keys.privateKey, _nodeForge().default.md.sha256.create());
   const privPem = pki.privateKeyToPem(keys.privateKey);
   const certPem = pki.certificateToPem(cert);
   await fs.mkdirp(certDirectory);

package/lib/getExisting.js

@@ -5,7 +5,15 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = getExisting;
 
-var _fs = _interopRequireDefault(require("fs"));
+function _fs() {
+  const data = _interopRequireDefault(require("fs"));
+
+  _fs = function () {
+    return data;
+  };
+
+  return data;
+}
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
@@ -14,10 +22,10 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * e.g. builtins.min.js and builtins.js.
  */
 function getExisting(minifiedPath, sourcePath) {
-  let source = _fs.default.readFileSync(sourcePath, 'utf8').trim();
+  let source = _fs().default.readFileSync(sourcePath, 'utf8').trim();
 
   return {
     source,
-    minified: _fs.default.existsSync(minifiedPath) ? _fs.default.readFileSync(minifiedPath, 'utf8').trim().replace(/;$/, '') : source
+    minified: _fs().default.existsSync(minifiedPath) ? _fs().default.readFileSync(minifiedPath, 'utf8').trim().replace(/;$/, '') : source
   };
 }

package/lib/getRootDir.js

@@ -7,13 +7,24 @@ exports.default = getRootDir;
 
 var _glob = require("./glob");
 
-const path = require('path');
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+
+  _path = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function getRootDir(files) {
   let cur = null;
 
   for (let file of files) {
-    let parsed = path.parse(file);
+    let parsed = _path().default.parse(file);
+
     parsed.dir = findGlobRoot(parsed.dir);
 
     if (!cur) {
@@ -24,8 +35,8 @@ function getRootDir(files) {
       return process.cwd();
     } else {
       // find the common path parts.
-      let curParts = cur.dir.split(path.sep);
-      let newParts = parsed.dir.split(path.sep);
+      let curParts = cur.dir.split(_path().default.sep);
+      let newParts = parsed.dir.split(_path().default.sep);
       let len = Math.min(curParts.length, newParts.length);
       let i = 0;
 
@@ -33,7 +44,7 @@ function getRootDir(files) {
         i++;
       }
 
-      cur.dir = i > 1 ? curParts.slice(0, i).join(path.sep) : cur.root;
+      cur.dir = i > 1 ? curParts.slice(0, i).join(_path().default.sep) : cur.root;
     }
   }
 
@@ -42,7 +53,7 @@ function getRootDir(files) {
 
 
 function findGlobRoot(dir) {
-  let parts = dir.split(path.sep);
+  let parts = dir.split(_path().default.sep);
   let last = parts.length;
 
   for (let i = parts.length - 1; i >= 0; i--) {
@@ -51,5 +62,5 @@ function findGlobRoot(dir) {
     }
   }
 
-  return parts.slice(0, last).join(path.sep);
+  return parts.slice(0, last).join(_path().default.sep);
 }

package/lib/glob.js

@@ -8,43 +8,76 @@ exports.isGlobMatch = isGlobMatch;
 exports.globSync = globSync;
 exports.glob = glob;
 
-var _isGlob2 = _interopRequireDefault(require("is-glob"));
+function _isGlob2() {
+  const data = _interopRequireDefault(require("is-glob"));
 
-var _fastGlob = _interopRequireDefault(require("fast-glob"));
+  _isGlob2 = function () {
+    return data;
+  };
 
-var _micromatch = require("micromatch");
+  return data;
+}
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _fastGlob() {
+  const data = _interopRequireDefault(require("fast-glob"));
 
-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; }
+  _fastGlob = function () {
+    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; }
+  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; }
+function _micromatch() {
+  const data = require("micromatch");
 
-function normalizePath(p) {
-  return p.replace(/\\/g, '/');
+  _micromatch = function () {
+    return data;
+  };
+
+  return data;
 }
 
+var _path = require("./path");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 function isGlob(p) {
-  return (0, _isGlob2.default)(normalizePath(p));
+  return (0, _isGlob2().default)((0, _path.normalizeSeparators)(p));
 }
 
 function isGlobMatch(filePath, glob) {
-  return (0, _micromatch.isMatch)(filePath, normalizePath(glob));
+  return (0, _micromatch().isMatch)(filePath, (0, _path.normalizeSeparators)(glob));
 }
 
-function globSync(p, options) {
-  return _fastGlob.default.sync(normalizePath(p), options);
+function globSync(p, fs, options) {
+  // $FlowFixMe
+  options = { ...options,
+    fs: {
+      statSync: p => {
+        return fs.statSync(p);
+      },
+      lstatSync: p => {
+        // Our FileSystem interface doesn't have lstat support at the moment,
+        // but this is fine for our purposes since we follow symlinks by default.
+        return fs.statSync(p);
+      },
+      readdirSync: (p, opts) => {
+        return fs.readdirSync(p, opts);
+      }
+    }
+  }; // $FlowFixMe
+
+  return _fastGlob().default.sync((0, _path.normalizeSeparators)(p), options);
 }
 
 function glob(p, fs, options) {
   // $FlowFixMe
-  options = _objectSpread({}, options, {
+  options = { ...options,
     fs: {
       stat: async (p, cb) => {
         try {
-          cb(null, (await fs.stat(p)));
+          cb(null, await fs.stat(p));
         } catch (err) {
           cb(err);
         }
@@ -53,7 +86,7 @@ function glob(p, fs, options) {
         // Our FileSystem interface doesn't have lstat support at the moment,
         // but this is fine for our purposes since we follow symlinks by default.
         try {
-          cb(null, (await fs.stat(p)));
+          cb(null, await fs.stat(p));
         } catch (err) {
           cb(err);
         }
@@ -65,12 +98,13 @@ function glob(p, fs, options) {
         }
 
         try {
-          cb(null, (await fs.readdir(p, opts)));
+          cb(null, await fs.readdir(p, opts));
         } catch (err) {
           cb(err);
         }
       }
     }
-  });
-  return (0, _fastGlob.default)(normalizePath(p), options);
+  }; // $FlowFixMe Added in Flow 0.121.0 upgrade in #4381
+
+  return (0, _fastGlob().default)((0, _path.normalizeSeparators)(p), options);
 }

package/lib/hash.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hashStream = hashStream;
+exports.hashObject = hashObject;
+exports.hashFile = hashFile;
+
+var _collection = require("./collection");
+
+function _hash() {
+  const data = require("@parcel/hash");
+
+  _hash = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function hashStream(stream) {
+  let hash = new (_hash().Hash)();
+  return new Promise((resolve, reject) => {
+    stream.on('error', err => {
+      reject(err);
+    });
+    stream.on('data', chunk => {
+      hash.writeBuffer(chunk);
+    }).on('end', function () {
+      resolve(hash.finish());
+    }).on('error', err => {
+      reject(err);
+    });
+  });
+}
+
+function hashObject(obj) {
+  return (0, _hash().hashString)(JSON.stringify((0, _collection.objectSortedEntriesDeep)(obj)));
+}
+
+function hashFile(fs, filePath) {
+  return hashStream(fs.createReadStream(filePath));
+}

package/lib/http-server.js

@@ -5,13 +5,37 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createHTTPServer = createHTTPServer;
 
-var _http = _interopRequireDefault(require("http"));
+function _http() {
+  const data = _interopRequireDefault(require("http"));
 
-var _https = _interopRequireDefault(require("https"));
+  _http = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _https() {
+  const data = _interopRequireDefault(require("https"));
+
+  _https = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+
+  _nullthrows = function () {
+    return data;
+  };
 
-var _nullthrows = _interopRequireDefault(require("nullthrows"));
+  return data;
+}
 
-var _ = require("../");
+var _ = require("./");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
@@ -21,11 +45,25 @@ async function createHTTPServer(options) {
   let server;
 
   if (!options.https) {
-    server = _http.default.createServer(options.listener);
+    server = _http().default.createServer(options.listener);
   } else if (options.https === true) {
-    server = _https.default.createServer((await (0, _.generateCertificate)(options.outputFS, options.cacheDir, options.host)), options.listener);
+    let {
+      cert,
+      key
+    } = await (0, _.generateCertificate)(options.outputFS, options.cacheDir, options.host);
+    server = _https().default.createServer({
+      cert,
+      key
+    }, options.listener);
   } else {
-    server = _https.default.createServer((await (0, _.getCertificate)(options.inputFS, options.https)), options.listener);
+    let {
+      cert,
+      key
+    } = await (0, _.getCertificate)(options.inputFS, options.https);
+    server = _https().default.createServer({
+      cert,
+      key
+    }, options.listener);
   } // HTTPServer#close only stops accepting new connections, and does not close existing ones.
   // Before closing, destroy any active connections through their sockets. Additionally, remove sockets when they close:
   // https://stackoverflow.com/questions/18874689/force-close-all-connections-in-a-node-js-http-server
@@ -34,9 +72,9 @@ async function createHTTPServer(options) {
 
   let sockets = new Set();
   server.on('connection', socket => {
-    (0, _nullthrows.default)(sockets).add(socket);
+    (0, _nullthrows().default)(sockets).add(socket);
     socket.on('close', () => {
-      (0, _nullthrows.default)(sockets).delete(socket);
+      (0, _nullthrows().default)(sockets).delete(socket);
     });
   });
   return {
@@ -44,7 +82,7 @@ async function createHTTPServer(options) {
 
     stop() {
       return new Promise((resolve, reject) => {
-        for (let socket of (0, _nullthrows.default)(sockets)) {
+        for (let socket of (0, _nullthrows().default)(sockets)) {
           socket.destroy();
         }