@parcel/utils 2.0.0-beta.1 → 2.0.0-nightly.1002

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/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,21 +5,52 @@ import type {FileSystem} from '@parcel/fs';
 
 import _isGlob from 'is-glob';
 import fastGlob, {type FastGlobOptions} from 'fast-glob';
-import {isMatch} from 'micromatch';
+import {isMatch, makeRe, type Options} from 'micromatch';
 import {normalizeSeparators} from './path';
 
-export function isGlob(p: FilePath) {
+export function isGlob(p: FilePath): any {
   return _isGlob(normalizeSeparators(p));
 }
 
-export function isGlobMatch(filePath: FilePath, glob: Glob) {
-  return isMatch(filePath, normalizeSeparators(glob));
+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 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> {
+  // $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);
 }
 

package/src/hash.js

@@ -0,0 +1,34 @@
+// @flow strict-local
+
+import type {Readable} from 'stream';
+import type {FileSystem} from '@parcel/fs';
+
+import {objectSortedEntriesDeep} from './collection';
+import {hashString, Hash} from '@parcel/hash';
+
+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)));
+}
+
+export function hashFile(fs: FileSystem, filePath: string): Promise<string> {
+  return hashStream(fs.createReadStream(filePath));
+}

package/src/http-server.js

@@ -7,10 +7,9 @@ import type {FilePath, HTTPSOptions} from '@parcel/types';
 import type {FileSystem} from '@parcel/fs';
 
 import http from 'http';
-// $FlowFixMe Flow does not know of http2's existance
-import {createSecureServer} from 'http2';
+import https from 'https';
 import nullthrows from 'nullthrows';
-import {getCertificate, generateCertificate} from '../';
+import {getCertificate, generateCertificate} from './';
 
 type CreateHTTPServerOpts = {|
   https: ?(HTTPSOptions | boolean),
@@ -41,17 +40,11 @@ export async function createHTTPServer(
       options.host,
     );
 
-    server = createSecureServer(
-      {cert, key, allowHTTP1: true},
-      options.listener,
-    );
+    server = https.createServer({cert, key}, options.listener);
   } else {
     let {cert, key} = await getCertificate(options.inputFS, options.https);
 
-    server = createSecureServer(
-      {cert, key, allowHTTP1: true},
-      options.listener,
-    );
+    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,7 +1,11 @@
 // @flow strict-local
 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 generateBuildMetrics} from './generateBuildMetrics';
@@ -14,8 +18,6 @@ export {default as objectHash} from './objectHash';
 export {default as prettifyTime} from './prettifyTime';
 export {default as prettyDiagnostic} from './prettyDiagnostic';
 export {default as PromiseQueue} from './PromiseQueue';
-// flowlint-next-line untyped-import:off
-export {default as promisify} from './promisify';
 export {default as validateSchema} from './schema';
 export {default as TapStream} from './TapStream';
 export {default as urlJoin} from './urlJoin';
@@ -25,21 +27,46 @@ 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';
-export * from './sourcemap';
+// 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,
+  setIntersect,
+  setUnion,
+} from './collection';
+export {resolveConfig, resolveConfigSync, loadConfig} from './config';
+export {DefaultMap, DefaultWeakMap} from './DefaultMap';
+export {makeDeferredWithPromise} from './Deferred';
+export {isGlob, isGlobMatch, 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';

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

@@ -2,7 +2,10 @@
 import type {FilePath} from '@parcel/types';
 import path from 'path';
 
-export default function isDirectoryInside(child: FilePath, parent: FilePath) {
+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

@@ -49,7 +49,9 @@ function getAppName(appName: string): string {
 export default async function openInBrowser(url: string, browser: string) {
   try {
     const options =
-      typeof browser === 'string' ? {app: [getAppName(browser)]} : undefined;
+      typeof browser === 'string' && browser.length > 0
+        ? {app: [getAppName(browser)]}
+        : undefined;
 
     await open(url, options);
   } catch (err) {

package/src/path.js

@@ -2,8 +2,13 @@
 import type {FilePath} from '@parcel/types';
 import path from 'path';
 
+const ABSOLUTE_PATH_REGEX = /^([a-zA-Z]:){0,1}[\\/]+/;
 const SEPARATOR_REGEX = /[\\]+/g;
 
+export function isAbsolute(filepath: string): boolean {
+  return ABSOLUTE_PATH_REGEX.test(filepath);
+}
+
 export function normalizeSeparators(filePath: FilePath): FilePath {
   return filePath.replace(SEPARATOR_REGEX, '/');
 }
@@ -17,7 +22,12 @@ export function normalizePath(
   filePath: FilePath,
   leadingDotSlash: boolean = true,
 ): FilePath {
-  if (leadingDotSlash && filePath[0] !== '.' && filePath[0] !== '/') {
+  if (
+    leadingDotSlash &&
+    (filePath[0] !== '.' ||
+      (filePath[1] !== '.' && filePath[1] !== '/' && filePath[1] !== '\\')) &&
+    !path.isAbsolute(filePath)
+  ) {
     return normalizeSeparators('./' + filePath);
   } else {
     return normalizeSeparators(filePath);
@@ -28,6 +38,11 @@ export function relativePath(
   from: string,
   to: string,
   leadingDotSlash: boolean = true,
-) {
+): FilePath {
+  // Fast path
+  if (to.startsWith(from + '/')) {
+    return (leadingDotSlash ? './' : '') + to.slice(from.length + 1);
+  }
+
   return normalizePath(path.relative(from, to), leadingDotSlash);
 }

package/src/prettyDiagnostic.js

@@ -7,12 +7,15 @@ import mdAnsi from '@parcel/markdown-ansi';
 import chalk from 'chalk';
 import path from 'path';
 import nullthrows from 'nullthrows';
+// $FlowFixMe
+import terminalLink from 'terminal-link';
 
 export type AnsiDiagnosticResult = {|
   message: string,
   stack: string,
   codeframe: string,
   hints: Array<string>,
+  documentation: string,
 |};
 
 export default async function prettyDiagnostic(
@@ -24,17 +27,12 @@ export default async function prettyDiagnostic(
     origin,
     message,
     stack,
-    codeFrame,
+    codeFrames,
     hints,
-    filePath,
-    language,
     skipFormatting,
+    documentationURL,
   } = diagnostic;
 
-  if (filePath != null && options && !path.isAbsolute(filePath)) {
-    filePath = path.join(options.projectRoot, filePath);
-  }
-
   let result = {
     message:
       mdAnsi(`**${origin ?? 'unknown'}**: `) +
@@ -42,42 +40,50 @@ export default async function prettyDiagnostic(
     stack: '',
     codeframe: '',
     hints: [],
+    documentation: '',
   };
 
-  if (codeFrame !== undefined) {
-    let highlights = Array.isArray(codeFrame.codeHighlights)
-      ? codeFrame.codeHighlights
-      : [codeFrame.codeHighlights];
+  if (codeFrames != null) {
+    for (let codeFrame of codeFrames) {
+      let filePath = codeFrame.filePath;
+      if (filePath != null && options && !path.isAbsolute(filePath)) {
+        filePath = path.join(options.projectRoot, filePath);
+      }
 
-    let code =
-      codeFrame.code ??
-      (options &&
-        (await options.inputFS.readFile(nullthrows(filePath), 'utf8')));
+      let highlights = codeFrame.codeHighlights;
+      let code =
+        codeFrame.code ??
+        (options &&
+          (await options.inputFS.readFile(nullthrows(filePath), 'utf8')));
 
-    if (code != null) {
-      let formattedCodeFrame = formatCodeFrame(code, highlights, {
-        useColor: true,
-        syntaxHighlighting: true,
-        language:
-          // $FlowFixMe sketchy null checks do not matter here...
-          language || (filePath ? path.extname(filePath).substr(1) : undefined),
-        terminalWidth,
-      });
+      let formattedCodeFrame = '';
+      if (code != null) {
+        formattedCodeFrame = formatCodeFrame(code, highlights, {
+          useColor: true,
+          syntaxHighlighting: true,
+          language:
+            // $FlowFixMe sketchy null checks do not matter here...
+            codeFrame.language ||
+            (filePath != null ? path.extname(filePath).substr(1) : undefined),
+          terminalWidth,
+        });
+      }
 
       result.codeframe +=
         typeof filePath !== 'string'
           ? ''
-          : chalk.underline(
+          : chalk.gray.underline(
               `${filePath}:${highlights[0].start.line}:${highlights[0].start.column}\n`,
             );
       result.codeframe += formattedCodeFrame;
+      if (codeFrame !== codeFrames[codeFrames.length - 1]) {
+        result.codeframe += '\n\n';
+      }
     }
   }
 
   if (stack != null) {
     result.stack = stack;
-  } else if (filePath != null && result.codeframe == null) {
-    result.stack = filePath;
   }
 
   if (Array.isArray(hints) && hints.length) {
@@ -86,5 +92,11 @@ export default async function prettyDiagnostic(
     });
   }
 
+  if (documentationURL != null) {
+    result.documentation = terminalLink('Learn more', documentationURL, {
+      fallback: (text, url) => `${text}: ${url}`,
+    });
+  }
+
   return result;
 }

package/src/relativeBundlePath.js

@@ -1,6 +1,6 @@
 // @flow strict-local
 
-import type {NamedBundle} from '@parcel/types';
+import type {FilePath, NamedBundle} from '@parcel/types';
 
 import path from 'path';
 import {relativePath} from './path';
@@ -9,10 +9,8 @@ export function relativeBundlePath(
   from: NamedBundle,
   to: NamedBundle,
   opts: {|leadingDotSlash: boolean|} = {leadingDotSlash: true},
-) {
-  return relativePath(
-    path.dirname(from.filePath),
-    to.filePath,
-    opts.leadingDotSlash,
-  );
+): FilePath {
+  let fromPath = path.join(from.target.distDir, from.name);
+  let toPath = path.join(to.target.distDir, to.name);
+  return relativePath(path.dirname(fromPath), toPath, opts.leadingDotSlash);
 }

package/src/replaceBundleReferences.js

@@ -10,11 +10,11 @@ import type {
   NamedBundle,
 } from '@parcel/types';
 
-import invariant from 'assert';
 import {Readable} from 'stream';
 import nullthrows from 'nullthrows';
+import invariant from 'assert';
 import URL from 'url';
-import {bufferStream, relativeBundlePath, urlJoin} from '../';
+import {bufferStream, relativeBundlePath, urlJoin} from './';
 
 type ReplacementMap = Map<
   string /* dependency id */,
@@ -23,7 +23,7 @@ type ReplacementMap = Map<
 
 /*
  * Replaces references to dependency ids for URL dependencies with:
- *   - in the case of an unresolvable url dependency, the original moduleSpecifier.
+ *   - in the case of an unresolvable url dependency, the original specifier.
  *     These are external requests that Parcel did not bundle.
  *   - in the case of a reference to another bundle, the relative url to that
  *     bundle from the current bundle.
@@ -44,39 +44,40 @@ export function replaceURLReferences({
   let replacements = new Map();
   let urlDependencies = [];
   bundle.traverse(node => {
-    if (node.type === 'dependency' && node.value.isURL) {
+    if (node.type === 'dependency' && node.value.specifierType === 'url') {
       urlDependencies.push(node.value);
     }
   });
 
   for (let dependency of urlDependencies) {
-    if (!dependency.isURL) {
+    if (dependency.specifierType !== 'url') {
       continue;
     }
 
-    let resolved = bundleGraph.resolveExternalDependency(dependency, bundle);
+    let placeholder = dependency.meta?.placeholder ?? dependency.id;
+    invariant(typeof placeholder === 'string');
+
+    let resolved = bundleGraph.getReferencedBundle(dependency, bundle);
     if (resolved == null) {
-      replacements.set(dependency.id, {
-        from: dependency.id,
-        to: dependency.moduleSpecifier,
+      replacements.set(placeholder, {
+        from: placeholder,
+        to: dependency.specifier,
       });
       continue;
     }
 
-    invariant(resolved.type === 'bundle_group');
-    let entryBundle = bundleGraph.getBundlesInBundleGroup(resolved.value).pop();
-    if (entryBundle.isInline) {
+    if (resolved.bundleBehavior === 'inline') {
       // If a bundle is inline, it should be replaced with inline contents,
       // not a URL.
       continue;
     }
 
     replacements.set(
-      dependency.id,
+      placeholder,
       getURLReplacement({
         dependency,
         fromBundle: bundle,
-        toBundle: entryBundle,
+        toBundle: resolved,
         relative,
       }),
     );
@@ -121,13 +122,8 @@ export async function replaceInlineReferences({
   });
 
   for (let dependency of dependencies) {
-    let resolved = bundleGraph.resolveExternalDependency(dependency, bundle);
-    if (resolved == null || resolved.type === 'asset') {
-      continue;
-    }
-
-    let [entryBundle] = bundleGraph.getBundlesInBundleGroup(resolved.value);
-    if (!entryBundle.isInline) {
+    let entryBundle = bundleGraph.getReferencedBundle(dependency, bundle);
+    if (entryBundle?.bundleBehavior !== 'inline') {
       continue;
     }
 
@@ -135,15 +131,18 @@ export async function replaceInlineReferences({
       entryBundle,
       bundleGraph,
     );
-    let packagedContents = (packagedBundle.contents instanceof Readable
-      ? await bufferStream(packagedBundle.contents)
-      : packagedBundle.contents
+    let packagedContents = (
+      packagedBundle.contents instanceof Readable
+        ? await bufferStream(packagedBundle.contents)
+        : packagedBundle.contents
     ).toString();
 
     let inlineType = nullthrows(entryBundle.getMainEntry()).meta.inlineType;
     if (inlineType == null || inlineType === 'string') {
+      let placeholder = dependency.meta?.placeholder ?? dependency.id;
+      invariant(typeof placeholder === 'string');
       replacements.set(
-        dependency.id,
+        placeholder,
         getInlineReplacement(dependency, inlineType, packagedContents),
       );
     }
@@ -152,7 +151,7 @@ export async function replaceInlineReferences({
   return performReplacement(replacements, contents, map);
 }
 
-function getURLReplacement({
+export function getURLReplacement({
   dependency,
   fromBundle,
   toBundle,
@@ -162,21 +161,38 @@ function getURLReplacement({
   fromBundle: NamedBundle,
   toBundle: NamedBundle,
   relative: boolean,
-|}) {
-  let url = URL.parse(dependency.moduleSpecifier);
+|}): {|from: string, to: string|} {
   let to;
+
+  let orig = URL.parse(dependency.specifier);
+
   if (relative) {
-    url.pathname = relativeBundlePath(fromBundle, toBundle, {
-      leadingDotSlash: false,
+    to = URL.format({
+      pathname: relativeBundlePath(fromBundle, toBundle, {
+        leadingDotSlash: false,
+      }),
+      hash: orig.hash,
     });
-    to = URL.format(url);
+
+    // If the resulting path includes a colon character and doesn't start with a ./ or ../
+    // we need to add one so that the first part before the colon isn't parsed as a URL protocol.
+    if (to.includes(':') && !to.startsWith('./') && !to.startsWith('../')) {
+      to = './' + to;
+    }
   } else {
-    url.pathname = nullthrows(toBundle.name);
-    to = urlJoin(toBundle.target.publicUrl, URL.format(url));
+    to = urlJoin(
+      toBundle.target.publicUrl,
+      URL.format({
+        pathname: nullthrows(toBundle.name),
+        hash: orig.hash,
+      }),
+    );
   }
 
+  let placeholder = dependency.meta?.placeholder ?? dependency.id;
+  invariant(typeof placeholder === 'string');
   return {
-    from: dependency.id,
+    from: placeholder,
     to,
   };
 }