@parcel/utils 2.0.0-nightly.150 → 2.0.0-nightly.1501

package/src/dependency-location.js

@@ -1,17 +1,22 @@
 // @flow
+
 export default function createDependencyLocation(
-  start: {|
+  start: interface {
     line: number,
     column: number,
-  |},
-  moduleSpecifier: string,
+  },
+  specifier: string,
   lineOffset: number = 0,
   columnOffset: number = 0,
   // Imports are usually wrapped in quotes
   importWrapperLength: number = 2,
-) {
+): {|
+  end: {|column: number, line: number|},
+  filePath: string,
+  start: {|column: number, line: number|},
+|} {
   return {
-    filePath: moduleSpecifier,
+    filePath: specifier,
     start: {
       line: start.line + lineOffset,
       column: start.column + columnOffset,
@@ -20,7 +25,7 @@ export default function createDependencyLocation(
       line: start.line + lineOffset,
       column:
         start.column +
-        moduleSpecifier.length -
+        specifier.length -
         1 +
         importWrapperLength +
         columnOffset,

package/src/generateBuildMetrics.js

@@ -0,0 +1,158 @@
+// @flow
+
+import type {FilePath, PackagedBundle} from '@parcel/types';
+import type {FileSystem} from '@parcel/fs';
+import SourceMap from '@parcel/source-map';
+import nullthrows from 'nullthrows';
+import path from 'path';
+import {loadSourceMapUrl} from './';
+
+export type AssetStats = {|
+  filePath: string,
+  size: number,
+  originalSize: number,
+  time: number,
+|};
+
+export type BundleStats = {|
+  filePath: string,
+  size: number,
+  time: number,
+  assets: Array<AssetStats>,
+|};
+
+export type BuildMetrics = {|
+  bundles: Array<BundleStats>,
+|};
+
+async function getSourcemapSizes(
+  filePath: FilePath,
+  fs: FileSystem,
+  projectRoot: FilePath,
+): Promise<?Map<string, number>> {
+  let bundleContents = await fs.readFile(filePath, 'utf-8');
+  let mapUrlData = await loadSourceMapUrl(fs, filePath, bundleContents);
+  if (!mapUrlData) {
+    return null;
+  }
+
+  let rawMap = mapUrlData.map;
+  let sourceMap = new SourceMap(projectRoot);
+  sourceMap.addVLQMap(rawMap);
+  let parsedMapData = sourceMap.getMap();
+
+  if (parsedMapData.mappings.length > 2) {
+    let sources = parsedMapData.sources.map(s =>
+      path.normalize(path.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: number = 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: PackagedBundle,
+  fs: FileSystem,
+  projectRoot: FilePath,
+) {
+  let filePath = bundle.filePath;
+  let sourcemapSizes = await getSourcemapSizes(filePath, fs, projectRoot);
+
+  let assets: Map<string, AssetStats> = new Map();
+  bundle.traverseAssets(asset => {
+    let filePath = path.normalize(asset.filePath);
+    assets.set(filePath, {
+      filePath,
+      size: asset.stats.size,
+      originalSize: asset.stats.size,
+      time: asset.stats.time,
+    });
+  });
+
+  let assetsReport: Array<AssetStats> = [];
+  if (sourcemapSizes && sourcemapSizes.size) {
+    assetsReport = Array.from(sourcemapSizes.keys()).map((filePath: string) => {
+      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: nullthrows(bundle.filePath),
+    size: bundle.stats.size,
+    time: bundle.stats.time,
+    assets: assetsReport.sort((a, b) => b.size - a.size),
+  };
+}
+
+export default async function generateBuildMetrics(
+  bundles: Array<PackagedBundle>,
+  fs: FileSystem,
+  projectRoot: FilePath,
+): Promise<BuildMetrics> {
+  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/src/generateCertificate.js

@@ -8,7 +8,7 @@ export default async function generateCertificate(
   fs: FileSystem,
   cacheDir: string,
   host: ?string,
-) {
+): Promise<{|cert: Buffer, key: Buffer|}> {
   let certDirectory = cacheDir;
 
   const privateKeyPath = path.join(certDirectory, 'private.pem');

package/src/getCertificate.js

@@ -5,7 +5,7 @@ import type {FileSystem} from '@parcel/fs';
 export default async function getCertificate(
   fs: FileSystem,
   options: HTTPSOptions,
-) {
+): Promise<{|cert: Buffer, key: Buffer|}> {
   try {
     let cert = await fs.readFile(options.cert);
     let key = await fs.readFile(options.key);

package/src/getExisting.js

@@ -14,10 +14,7 @@ export default function getExisting(
   return {
     source,
     minified: fs.existsSync(minifiedPath)
-      ? fs
-          .readFileSync(minifiedPath, 'utf8')
-          .trim()
-          .replace(/;$/, '')
+      ? fs.readFileSync(minifiedPath, 'utf8').trim().replace(/;$/, '')
       : source,
   };
 }

package/src/getModuleParts.js

@@ -0,0 +1,23 @@
+// @flow strict-local
+import path from 'path';
+
+import {normalizeSeparators} from './path';
+
+/**
+ * Returns the package name and the optional subpath
+ */
+export default function getModuleParts(_name: string): [string, ?string] {
+  let name = path.normalize(_name);
+  let splitOn = name.indexOf(path.sep);
+  if (name.charAt(0) === '@') {
+    splitOn = name.indexOf(path.sep, splitOn + 1);
+  }
+  if (splitOn < 0) {
+    return [normalizeSeparators(name), undefined];
+  } else {
+    return [
+      normalizeSeparators(name.substring(0, splitOn)),
+      name.substring(splitOn + 1) || undefined,
+    ];
+  }
+}

package/src/getRootDir.js

@@ -2,8 +2,7 @@
 
 import type {FilePath} from '@parcel/types';
 import {isGlob} from './glob';
-
-const path = require('path');
+import path from 'path';
 
 export default function getRootDir(files: Array<FilePath>): FilePath {
   let cur = null;

package/src/glob.js

@@ -5,25 +5,65 @@ import type {FileSystem} from '@parcel/fs';
 
 import _isGlob from 'is-glob';
 import fastGlob, {type FastGlobOptions} from 'fast-glob';
-import {isMatch} from 'micromatch';
+import micromatch, {isMatch, makeRe, type Options} from 'micromatch';
+import {normalizeSeparators} from './path';
 
-function normalizePath(p: string): string {
-  return p.replace(/\\/g, '/');
+export function isGlob(p: FilePath): any {
+  return _isGlob(normalizeSeparators(p));
 }
 
-export function isGlob(p: FilePath) {
-  return _isGlob(normalizePath(p));
+export function isGlobMatch(
+  filePath: FilePath,
+  glob: Glob | Array<Glob>,
+  opts?: Options,
+): any {
+  glob = Array.isArray(glob)
+    ? glob.map(normalizeSeparators)
+    : normalizeSeparators(glob);
+  return isMatch(filePath, glob, opts);
 }
 
-export function isGlobMatch(filePath: FilePath, glob: Glob) {
-  return isMatch(filePath, normalizePath(glob));
+export function globMatch(
+  values: Array<string>,
+  glob: Glob | Array<Glob>,
+  opts?: Options,
+): Array<string> {
+  glob = Array.isArray(glob)
+    ? glob.map(normalizeSeparators)
+    : normalizeSeparators(glob);
+
+  return micromatch(values, glob, opts);
+}
+
+export function globToRegex(glob: Glob, opts?: Options): RegExp {
+  return makeRe(glob, opts);
 }
 
 export function globSync(
   p: FilePath,
-  options: FastGlobOptions<FilePath>,
+  fs: FileSystem,
+  options?: FastGlobOptions<FilePath>,
 ): Array<FilePath> {
-  return fastGlob.sync(normalizePath(p), 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.sync(normalizeSeparators(p), options);
 }
 
 export function glob(
@@ -66,5 +106,6 @@ export function glob(
     },
   };
 
-  return fastGlob(normalizePath(p), options);
+  // $FlowFixMe Added in Flow 0.121.0 upgrade in #4381
+  return fastGlob(normalizeSeparators(p), options);
 }

package/src/hash.js

@@ -0,0 +1,49 @@
+// @flow strict-local
+
+import type {Readable} from 'stream';
+import type {FileSystem} from '@parcel/fs';
+
+import {objectSortedEntriesDeep} from './collection';
+import {hashString, Hash} from '@parcel/rust';
+
+export function hashStream(stream: Readable): Promise<string> {
+  let hash = new 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);
+      });
+  });
+}
+
+export function hashObject(obj: {+[string]: mixed, ...}): string {
+  return hashString(JSON.stringify(objectSortedEntriesDeep(obj)));
+}
+
+let testCache: {|[string]: Promise<string>|} = {
+  /*:: ...null */
+};
+export function hashFile(fs: FileSystem, filePath: string): Promise<string> {
+  if (process.env.PARCEL_BUILD_ENV === 'test') {
+    // Development builds of these native modules are especially big and slow to hash.
+    if (
+      /parcel-swc\.[^\\/]+\.node$|lightningcss.[^\\/]+.node$/.test(filePath)
+    ) {
+      let cacheEntry = testCache[filePath];
+      if (cacheEntry) return cacheEntry;
+      let v = hashStream(fs.createReadStream(filePath));
+      testCache[filePath] = v;
+      return v;
+    }
+  }
+  return hashStream(fs.createReadStream(filePath));
+}

package/src/http-server.js

@@ -1,7 +1,15 @@
 // @flow strict-local
 
-import type {Server as HTTPOnlyServer} from 'http';
-import type {Server as HTTPSServer} from 'https';
+import type {
+  Server as HTTPOnlyServer,
+  IncomingMessage as HTTPRequest,
+  ServerResponse as HTTPResponse,
+} from 'http';
+import type {
+  Server as HTTPSServer,
+  IncomingMessage as HTTPSRequest,
+  ServerResponse as HTTPSResponse,
+} from 'https';
 import type {Socket} from 'net';
 import type {FilePath, HTTPSOptions} from '@parcel/types';
 import type {FileSystem} from '@parcel/fs';
@@ -9,15 +17,19 @@ import type {FileSystem} from '@parcel/fs';
 import http from 'http';
 import https from 'https';
 import nullthrows from 'nullthrows';
-import {getCertificate, generateCertificate} from '../';
+import {getCertificate, generateCertificate} from './';
 
 type CreateHTTPServerOpts = {|
-  https: ?(HTTPSOptions | boolean),
-  inputFS: FileSystem,
-  outputFS: FileSystem,
-  cacheDir: FilePath,
-  listener?: (mixed, mixed) => void,
+  listener?: (HTTPRequest | HTTPSRequest, HTTPResponse | HTTPSResponse) => void,
   host?: string,
+  ...
+    | {|
+        https: ?(HTTPSOptions | boolean),
+        inputFS: FileSystem,
+        outputFS: FileSystem,
+        cacheDir: FilePath,
+      |}
+    | {||},
 |};
 
 export type HTTPServer = HTTPOnlyServer | HTTPSServer;
@@ -34,19 +46,17 @@ export async function createHTTPServer(
   if (!options.https) {
     server = http.createServer(options.listener);
   } else if (options.https === true) {
-    server = https.createServer(
-      await generateCertificate(
-        options.outputFS,
-        options.cacheDir,
-        options.host,
-      ),
-      options.listener,
+    let {cert, key} = await generateCertificate(
+      options.outputFS,
+      options.cacheDir,
+      options.host,
     );
+
+    server = https.createServer({cert, key}, options.listener);
   } else {
-    server = https.createServer(
-      await getCertificate(options.inputFS, options.https),
-      options.listener,
-    );
+    let {cert, key} = await getCertificate(options.inputFS, options.https);
+
+    server = https.createServer({cert, key}, options.listener);
   }
 
   // HTTPServer#close only stops accepting new connections, and does not close existing ones.

package/src/index.js

@@ -1,42 +1,88 @@
 // @flow strict-local
-export type * from './generateBundleReport';
+export type * from './config';
+export type * from './Deferred';
+export type * from './generateBuildMetrics';
+export type * from './http-server';
+export type * from './path';
 export type * from './prettyDiagnostic';
+export type * from './schema';
 
 export {default as countLines} from './countLines';
-export {default as generateBundleReport} from './generateBundleReport';
+export {default as generateBuildMetrics} from './generateBuildMetrics';
 export {default as generateCertificate} from './generateCertificate';
 export {default as getCertificate} from './getCertificate';
+export {default as getModuleParts} from './getModuleParts';
 export {default as getRootDir} from './getRootDir';
+export {default as isDirectoryInside} from './isDirectoryInside';
 export {default as isURL} from './is-url';
 export {default as objectHash} from './objectHash';
 export {default as prettifyTime} from './prettifyTime';
 export {default as prettyDiagnostic} from './prettyDiagnostic';
 export {default as PromiseQueue} from './PromiseQueue';
-// $FlowFixMe this is untyped
-export {default as promisify} from './promisify';
 export {default as validateSchema} from './schema';
 export {default as TapStream} from './TapStream';
 export {default as urlJoin} from './urlJoin';
-export {default as loadSourceMapUrl} from './loadSourceMapUrl';
 export {default as relativeUrl} from './relativeUrl';
 export {default as createDependencyLocation} from './dependency-location';
 export {default as debounce} from './debounce';
 export {default as throttle} from './throttle';
+export {default as openInBrowser} from './openInBrowser';
 
-export * from './blob';
-export * from './collection';
-export * from './config';
-export * from './DefaultMap';
-export * from './Deferred';
-export * from './glob';
-export * from './md5';
-export * from './schema';
-export * from './http-server';
-export * from './path';
-export * from './replaceBundleReferences';
-export * from './stream';
-export * from './resolve';
-export * from './relativeBundlePath';
-export * from './ansi-html';
-export * from './escape-html';
-export * from './escape-markdown';
+// Explicit re-exports instead of export * for lazy require performance
+export {findAlternativeNodeModules, findAlternativeFiles} from './alternatives';
+export {blobToBuffer, blobToString} from './blob';
+export {
+  unique,
+  objectSortedEntries,
+  objectSortedEntriesDeep,
+  setDifference,
+  setEqual,
+  setIntersect,
+  setUnion,
+} from './collection';
+export {
+  resolveConfig,
+  resolveConfigSync,
+  loadConfig,
+  readConfig,
+} from './config';
+export {DefaultMap, DefaultWeakMap} from './DefaultMap';
+export {makeDeferredWithPromise} from './Deferred';
+export {getProgressMessage} from './progress-message.js';
+export {
+  isGlob,
+  isGlobMatch,
+  globMatch,
+  globSync,
+  glob,
+  globToRegex,
+} from './glob';
+export {hashStream, hashObject, hashFile} from './hash';
+export {SharedBuffer} from './shared-buffer';
+export {fuzzySearch} from './schema';
+export {createHTTPServer} from './http-server';
+export {normalizePath, normalizeSeparators, relativePath} from './path';
+export {
+  replaceURLReferences,
+  replaceInlineReferences,
+} from './replaceBundleReferences';
+export {
+  measureStreamLength,
+  readableFromStringOrBuffer,
+  bufferStream,
+  blobToStream,
+  streamFromPromise,
+  fallbackStream,
+} from './stream';
+export {relativeBundlePath} from './relativeBundlePath';
+export {ansiHtml} from './ansi-html';
+export {escapeHTML} from './escape-html';
+export {
+  SOURCEMAP_RE,
+  SOURCEMAP_EXTENSIONS,
+  matchSourceMappingURL,
+  loadSourceMapUrl,
+  loadSourceMap,
+  remapSourceLocation,
+} from './sourcemap';
+export {default as stripAnsi} from 'strip-ansi';

package/src/is-url.js

@@ -1,6 +1,6 @@
 // @flow
 
-const _isURL = require('is-url');
+import _isURL from 'is-url';
 
 // Matches anchor (ie: #raptors)
 const ANCHOR_REGEXP = /^#/;

package/src/isDirectoryInside.js

@@ -0,0 +1,11 @@
+// @flow strict-local
+import type {FilePath} from '@parcel/types';
+import path from 'path';
+
+export default function isDirectoryInside(
+  child: FilePath,
+  parent: FilePath,
+): boolean {
+  const relative = path.relative(parent, child);
+  return !relative.startsWith('..') && !path.isAbsolute(relative);
+}

package/src/openInBrowser.js

@@ -0,0 +1,64 @@
+// @flow
+
+import open from 'open';
+import {execSync} from 'child_process';
+import logger from '@parcel/logger';
+
+// Chrome app name is platform dependent. we should not hard code it.
+// https://github.com/react-native-community/cli/blob/e2be8a905285d9b37512fc78c9755b9635ecf805/packages/cli/src/commands/server/launchDebugger.ts#L28
+function getChromeAppName(): string {
+  switch (process.platform) {
+    case 'darwin':
+      return 'google chrome';
+    case 'win32':
+      return 'chrome';
+    case 'linux':
+      if (commandExistsUnixSync('google-chrome')) {
+        return 'google-chrome';
+      }
+      if (commandExistsUnixSync('chromium-browser')) {
+        return 'chromium-browser';
+      }
+      return 'chromium';
+
+    default:
+      return 'google-chrome';
+  }
+}
+
+function commandExistsUnixSync(commandName: string) {
+  try {
+    const stdout = execSync(
+      `command -v ${commandName} 2>/dev/null` +
+        ` && { echo >&1 '${commandName} found'; exit 0; }`,
+    );
+    return !!stdout;
+  } catch (error) {
+    return false;
+  }
+}
+
+function getAppName(appName: string): string {
+  if (['google', 'chrome'].includes(appName)) {
+    return getChromeAppName();
+  } else if (['brave', 'Brave'].includes(appName)) {
+    return 'Brave Browser';
+  } else return appName;
+}
+
+export default async function openInBrowser(url: string, browser: string) {
+  try {
+    const options =
+      typeof browser === 'string' && browser.length > 0
+        ? {app: [getAppName(browser)]}
+        : undefined;
+
+    await open(url, options);
+  } catch (err) {
+    logger.error(
+      `Unexpected error while opening in browser: ${browser}`,
+      '@parcel/utils',
+    );
+    logger.error(err, '@parcel/utils');
+  }
+}