@parcel/utils 2.0.0-nightly.137 → 2.0.0-nightly.1373

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,41 +1,89 @@
 // @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';
+// 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 {BitSet} from './BitSet';
+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');
+  }
+}

package/src/path.js

@@ -1,16 +1,48 @@
 // @flow strict-local
-
 import type {FilePath} from '@parcel/types';
 import path from 'path';
 
-const COMMON_SEPARATORS = ['/', '\\'];
+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 {
-  let ret = filePath;
+  return filePath.replace(SEPARATOR_REGEX, '/');
+}
+
+export type PathOptions = {
+  noLeadingDotSlash?: boolean,
+  ...
+};
+
+export function normalizePath(
+  filePath: FilePath,
+  leadingDotSlash: boolean = true,
+): FilePath {
+  if (
+    leadingDotSlash &&
+    (filePath[0] !== '.' ||
+      (filePath[1] !== '.' && filePath[1] !== '/' && filePath[1] !== '\\')) &&
+    !path.isAbsolute(filePath)
+  ) {
+    return normalizeSeparators('./' + filePath);
+  } else {
+    return normalizeSeparators(filePath);
+  }
+}
 
-  for (let separator of COMMON_SEPARATORS) {
-    ret = ret.split(separator).join(path.sep);
+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 ret;
+  return normalizePath(path.relative(from, to), leadingDotSlash);
 }

package/src/prettyDiagnostic.js

@@ -1,61 +1,105 @@
 // @flow strict-local
 import type {Diagnostic} from '@parcel/diagnostic';
+import type {PluginOptions} from '@parcel/types';
 
 import formatCodeFrame from '@parcel/codeframe';
 import mdAnsi from '@parcel/markdown-ansi';
 import chalk from 'chalk';
 import path from 'path';
+// $FlowFixMe
+import terminalLink from 'terminal-link';
+
+export type FormattedCodeFrame = {|
+  location: string,
+  code: string,
+|};
 
 export type AnsiDiagnosticResult = {|
   message: string,
   stack: string,
+  /** A formatted string containing all code frames, including their file locations. */
   codeframe: string,
+  /** A list of code frames with highlighted code and file locations separately. */
+  frames: Array<FormattedCodeFrame>,
   hints: Array<string>,
+  documentation: string,
 |};
 
-export default function prettyDiagnostic(
+export default async function prettyDiagnostic(
   diagnostic: Diagnostic,
-): AnsiDiagnosticResult {
+  options?: PluginOptions,
+  terminalWidth?: number,
+): Promise<AnsiDiagnosticResult> {
   let {
     origin,
     message,
     stack,
-    codeFrame,
+    codeFrames,
     hints,
-    filePath,
-    language,
     skipFormatting,
+    documentationURL,
   } = diagnostic;
 
   let result = {
     message:
       mdAnsi(`**${origin ?? 'unknown'}**: `) +
       (skipFormatting ? message : mdAnsi(message)),
-    stack: stack ?? filePath ?? '',
+    stack: '',
     codeframe: '',
+    frames: [],
     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 formattedCodeFrame = formatCodeFrame(codeFrame.code, highlights, {
-      useColor: true,
-      syntaxHighlighting: true,
-      language:
-        // $FlowFixMe sketchy null checks do not matter here...
-        language || (filePath ? path.extname(filePath).substr(1) : undefined),
-    });
+      let highlights = codeFrame.codeHighlights;
+      let code = codeFrame.code;
+      if (code == null && options && filePath != null) {
+        code = await options.inputFS.readFile(filePath, 'utf8');
+      }
+
+      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,
+        });
+      }
+
+      let location;
+      if (typeof filePath !== 'string') {
+        location = '';
+      } else if (highlights.length === 0) {
+        location = filePath;
+      } else {
+        location = `${filePath}:${highlights[0].start.line}:${highlights[0].start.column}`;
+      }
+      result.codeframe += location ? chalk.gray.underline(location) + '\n' : '';
+      result.codeframe += formattedCodeFrame;
+      if (codeFrame !== codeFrames[codeFrames.length - 1]) {
+        result.codeframe += '\n\n';
+      }
 
-    result.codeframe +=
-      typeof filePath !== 'string'
-        ? ''
-        : chalk.underline(
-            `${filePath}:${highlights[0].start.line}:${highlights[0].start.column}\n`,
-          );
-    result.codeframe += formattedCodeFrame;
+      result.frames.push({
+        location,
+        code: formattedCodeFrame,
+      });
+    }
+  }
+
+  if (stack != null) {
+    result.stack = stack;
   }
 
   if (Array.isArray(hints) && hints.length) {
@@ -64,5 +108,11 @@ export default function prettyDiagnostic(
     });
   }
 
+  if (documentationURL != null) {
+    result.documentation = terminalLink('Learn more', documentationURL, {
+      fallback: (text, url) => `${text}: ${url}`,
+    });
+  }
+
   return result;
 }

package/src/progress-message.js

@@ -0,0 +1,22 @@
+// @flow strict-local
+import type {BuildProgressEvent} from '@parcel/types';
+
+import path from 'path';
+
+export function getProgressMessage(event: BuildProgressEvent): ?string {
+  switch (event.phase) {
+    case 'transforming':
+      return `Building ${path.basename(event.filePath)}...`;
+
+    case 'bundling':
+      return 'Bundling...';
+
+    case 'packaging':
+      return `Packaging ${event.bundle.displayName}...`;
+
+    case 'optimizing':
+      return `Optimizing ${event.bundle.displayName}...`;
+  }
+
+  return null;
+}

package/src/relativeBundlePath.js

@@ -1,21 +1,16 @@
 // @flow strict-local
 
-import type {Bundle} from '@parcel/types';
+import type {FilePath, NamedBundle} from '@parcel/types';
 
 import path from 'path';
-import nullthrows from 'nullthrows';
+import {relativePath} from './path';
 
 export function relativeBundlePath(
-  from: Bundle,
-  to: Bundle,
+  from: NamedBundle,
+  to: NamedBundle,
   opts: {|leadingDotSlash: boolean|} = {leadingDotSlash: true},
-) {
-  let p = path
-    .relative(path.dirname(nullthrows(from.filePath)), nullthrows(to.filePath))
-    .replace(/\\/g, '/');
-  if (opts.leadingDotSlash && p[0] !== '.') {
-    p = './' + p;
-  }
-
-  return p;
+): 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);
 }