@parcel/utils 2.0.0-beta.3 → 2.0.0-dev.1510

package/src/index.js

@@ -1,14 +1,17 @@
 // @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 type * from './http-server';
 
 export {default as countLines} from './countLines';
 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';
@@ -33,21 +36,32 @@ export {
   objectSortedEntries,
   objectSortedEntriesDeep,
   setDifference,
+  setEqual,
+  setIntersect,
+  setUnion,
 } from './collection';
-export {resolveConfig, resolveConfigSync, loadConfig} from './config';
+export {
+  resolveConfig,
+  resolveConfigSync,
+  loadConfig,
+  readConfig,
+} from './config';
 export {DefaultMap, DefaultWeakMap} from './DefaultMap';
 export {makeDeferredWithPromise} from './Deferred';
-export {isGlob, isGlobMatch, globSync, glob} from './glob';
+export {getProgressMessage} from './progress-message.js';
 export {
-  md5FromString,
-  md5FromReadableStream,
-  md5FromObject,
-  md5FromOrderedObject,
-  md5FromFilePath,
-} from './md5';
+  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 {normalizeSeparators, normalizePath, relativePath} from './path';
+export {normalizePath, normalizeSeparators, relativePath} from './path';
 export {
   replaceURLReferences,
   replaceInlineReferences,
@@ -71,3 +85,4 @@ export {
   loadSourceMap,
   remapSourceLocation,
 } from './sourcemap';
+export {default as stripAnsi} from 'strip-ansi';

package/src/path.js

@@ -22,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);
@@ -34,5 +39,10 @@ export function relativePath(
   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

@@ -3,86 +3,136 @@ 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 _mdAnsi from '@parcel/markdown-ansi';
+import _chalk from 'chalk';
 import path from 'path';
-import nullthrows from 'nullthrows';
+// $FlowFixMe
+import _terminalLink from 'terminal-link';
+
+/* eslint-disable import/no-extraneous-dependencies */
+// $FlowFixMe
+import snarkdown from 'snarkdown';
+/* eslint-enable import/no-extraneous-dependencies */
+
+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 async function prettyDiagnostic(
   diagnostic: Diagnostic,
   options?: PluginOptions,
   terminalWidth?: number,
+  format: 'ansi' | 'html' = 'ansi',
 ): Promise<AnsiDiagnosticResult> {
   let {
     origin,
     message,
     stack,
-    codeFrame,
+    codeFrames,
     hints,
-    filePath,
-    language,
     skipFormatting,
+    documentationURL,
   } = diagnostic;
 
-  if (filePath != null && options && !path.isAbsolute(filePath)) {
-    filePath = path.join(options.projectRoot, filePath);
-  }
+  const md = format === 'ansi' ? _mdAnsi : snarkdown;
+  const terminalLink =
+    format === 'ansi'
+      ? _terminalLink
+      : // eslint-disable-next-line no-unused-vars
+        (text, url, _) => `<a href="${url}">${text}</a>`;
+  const chalk =
+    format === 'ansi'
+      ? _chalk
+      : {
+          gray: {
+            underline: v =>
+              `<span style="color: grey; text-decoration: underline;">${v}</span>`,
+          },
+        };
 
   let result = {
     message:
-      mdAnsi(`**${origin ?? 'unknown'}**: `) +
-      (skipFormatting ? message : mdAnsi(message)),
+      md(`**${origin ?? 'unknown'}**: `) +
+      (skipFormatting ? message : md(message)),
     stack: '',
     codeframe: '',
+    frames: [],
     hints: [],
+    documentation: '',
   };
 
-  if (codeFrame !== undefined) {
-    let highlights = codeFrame.codeHighlights;
-    let code =
-      codeFrame.code ??
-      (options &&
-        (await options.inputFS.readFile(nullthrows(filePath), 'utf8')));
-
-    let formattedCodeFrame = '';
-    if (code != null) {
-      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,
+  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 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.frames.push({
+        location,
+        code: formattedCodeFrame,
       });
     }
-
-    result.codeframe +=
-      typeof filePath !== 'string'
-        ? ''
-        : chalk.underline(
-            `${filePath}:${highlights[0].start.line}:${highlights[0].start.column}\n`,
-          );
-    result.codeframe += formattedCodeFrame;
-  } else if (typeof filePath === 'string') {
-    result.codeframe += chalk.underline(filePath);
   }
 
   if (stack != null) {
     result.stack = stack;
-  } else if (filePath != null && result.codeframe == null) {
-    result.stack = filePath;
   }
 
   if (Array.isArray(hints) && hints.length) {
     result.hints = hints.map(h => {
-      return mdAnsi(h);
+      return md(h);
+    });
+  }
+
+  if (documentationURL != null) {
+    result.documentation = terminalLink('Learn more', documentationURL, {
+      fallback: (text, url) => `${text}: ${url}`,
     });
   }
 

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/replaceBundleReferences.js

@@ -12,6 +12,7 @@ import type {
 
 import {Readable} from 'stream';
 import nullthrows from 'nullthrows';
+import invariant from 'assert';
 import URL from 'url';
 import {bufferStream, relativeBundlePath, urlJoin} from './';
 
@@ -22,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.
@@ -32,6 +33,7 @@ export function replaceURLReferences({
   bundleGraph,
   contents,
   map,
+  getReplacement = s => s,
   relative = true,
 }: {|
   bundle: NamedBundle,
@@ -39,42 +41,47 @@ export function replaceURLReferences({
   contents: string,
   relative?: boolean,
   map?: ?SourceMap,
+  getReplacement?: string => string,
 |}): {|+contents: string, +map: ?SourceMap|} {
   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 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: getReplacement(dependency.specifier),
       });
       continue;
     }
 
-    if (!resolved || resolved.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: resolved,
         relative,
+        getReplacement,
       }),
     );
   }
@@ -119,7 +126,7 @@ export async function replaceInlineReferences({
 
   for (let dependency of dependencies) {
     let entryBundle = bundleGraph.getReferencedBundle(dependency, bundle);
-    if (!entryBundle?.isInline) {
+    if (entryBundle?.bundleBehavior !== 'inline') {
       continue;
     }
 
@@ -127,16 +134,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.getEntryAssets()[0]).meta
-      .inlineType;
+    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),
       );
     }
@@ -150,32 +159,47 @@ export function getURLReplacement({
   fromBundle,
   toBundle,
   relative,
+  getReplacement,
 }: {|
   dependency: Dependency,
   fromBundle: NamedBundle,
   toBundle: NamedBundle,
   relative: boolean,
+  getReplacement?: string => string,
 |}): {|from: string, to: string|} {
   let to;
 
+  let orig = URL.parse(dependency.specifier);
+
   if (relative) {
-    to = URL.format(
-      URL.parse(
-        relativeBundlePath(fromBundle, toBundle, {
-          leadingDotSlash: false,
-        }),
-      ),
-    );
+    to = URL.format({
+      pathname: relativeBundlePath(fromBundle, toBundle, {
+        leadingDotSlash: false,
+      }),
+      hash: orig.hash,
+    });
+
+    // 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 {
     to = urlJoin(
       toBundle.target.publicUrl,
-      URL.format(URL.parse(nullthrows(toBundle.name))),
+      URL.format({
+        pathname: nullthrows(toBundle.name),
+        hash: orig.hash,
+      }),
     );
   }
 
+  let placeholder = dependency.meta?.placeholder ?? dependency.id;
+  invariant(typeof placeholder === 'string');
+
   return {
-    from: dependency.id,
-    to,
+    from: placeholder,
+    to: getReplacement ? getReplacement(to) : to,
   };
 }
 

package/src/schema.js

@@ -4,10 +4,9 @@ import ThrowableDiagnostic, {
   escapeMarkdown,
   encodeJSONKeyComponent,
 } from '@parcel/diagnostic';
-import type {Mapping} from 'json-source-map';
+import type {Mapping} from '@mischnic/json-sourcemap';
 import nullthrows from 'nullthrows';
-// flowlint-next-line untyped-import:off
-import levenshtein from 'fastest-levenshtein';
+import * as levenshtein from 'fastest-levenshtein';
 
 export type SchemaEntity =
   | SchemaObject
@@ -378,7 +377,7 @@ export function fuzzySearch(
   return result.map(([v]) => v);
 }
 
-validateSchema.diagnostic = function(
+validateSchema.diagnostic = function (
   schema: SchemaEntity,
   data: {|
     ...
@@ -406,7 +405,7 @@ validateSchema.diagnostic = function(
     !data
   ) {
     throw new Error(
-      'At least one of data.source and data.source must be defined!',
+      'At least one of data.source and data.data must be defined!',
     );
   }
   let object = data.map
@@ -478,25 +477,27 @@ validateSchema.diagnostic = function(
       map = data.source ?? JSON.stringify(nullthrows(data.data), 0, '\t');
       code = map;
     }
-    let codeFrame = {
-      code,
-      codeHighlights: generateJSONCodeHighlights(
-        map,
-        keys.map(({key, type, message}) => ({
-          key: (data.prependKey ?? '') + key,
-          type: type,
-          message: message != null ? escapeMarkdown(message) : message,
-        })),
-      ),
-    };
+    let codeFrames = [
+      {
+        filePath: data.filePath ?? undefined,
+        language: 'json',
+        code,
+        codeHighlights: generateJSONCodeHighlights(
+          map,
+          keys.map(({key, type, message}) => ({
+            key: (data.prependKey ?? '') + key,
+            type: type,
+            message: message != null ? escapeMarkdown(message) : message,
+          })),
+        ),
+      },
+    ];
 
     throw new ThrowableDiagnostic({
       diagnostic: {
         message: message,
         origin,
-        filePath: data.filePath ?? undefined,
-        language: 'json',
-        codeFrame,
+        codeFrames,
       },
     });
   }

package/src/shared-buffer.js

@@ -0,0 +1,23 @@
+// @flow
+
+export let SharedBuffer: Class<ArrayBuffer> | Class<SharedArrayBuffer>;
+
+// $FlowFixMe[prop-missing]
+if (process.browser) {
+  SharedBuffer = ArrayBuffer;
+  // Safari has removed the constructor
+  if (typeof SharedArrayBuffer !== 'undefined') {
+    let channel = new MessageChannel();
+    try {
+      // Firefox might throw when sending the Buffer over a MessagePort
+      channel.port1.postMessage(new SharedArrayBuffer(0));
+      SharedBuffer = SharedArrayBuffer;
+    } catch (_) {
+      // NOOP
+    }
+    channel.port1.close();
+    channel.port2.close();
+  }
+} else {
+  SharedBuffer = SharedArrayBuffer;
+}

package/src/sourcemap.js

@@ -5,15 +5,18 @@ import SourceMap from '@parcel/source-map';
 import path from 'path';
 import {normalizeSeparators, isAbsolute} from './path';
 
-export const SOURCEMAP_RE: RegExp = /(?:\/\*|\/\/)\s*[@#]\s*sourceMappingURL\s*=\s*([^\s*]+)(?:\s*\*\/)?\s*$/;
+export const SOURCEMAP_RE: RegExp =
+  /(?:\/\*|\/\/)\s*[@#]\s*sourceMappingURL\s*=\s*([^\s*]+)(?:\s*\*\/)?\s*$/;
 const DATA_URL_RE = /^data:[^;]+(?:;charset=[^;]+)?;base64,(.*)/;
 export const SOURCEMAP_EXTENSIONS: Set<string> = new Set<string>([
+  'css',
+  'es',
+  'es6',
   'js',
   'jsx',
   'mjs',
-  'es',
-  'es6',
-  'css',
+  'ts',
+  'tsx',
 ]);
 
 export function matchSourceMappingURL(
@@ -91,8 +94,8 @@ export function remapSourceLocation(
   } = loc;
   let lineDiff = endLine - startLine;
   let colDiff = endCol - startCol;
-  let start = originalMap.findClosestMapping(startLine, startCol);
-  let end = originalMap.findClosestMapping(endLine, endCol);
+  let start = originalMap.findClosestMapping(startLine, startCol - 1);
+  let end = originalMap.findClosestMapping(endLine, endCol - 1);
 
   if (start?.original) {
     if (start.source) {
@@ -105,13 +108,16 @@ export function remapSourceLocation(
 
   if (end?.original) {
     ({line: endLine, column: endCol} = end.original);
-    endCol++;
+    endCol++; // source map columns are 0-based
 
     if (endLine < startLine) {
       endLine = startLine;
       endCol = startCol;
     } else if (endLine === startLine && endCol < startCol && lineDiff === 0) {
       endCol = startCol + colDiff;
+    } else if (endLine === startLine && startCol === endCol && lineDiff === 0) {
+      // Prevent 0-length ranges
+      endCol = startCol + 1;
     }
   } else {
     endLine = startLine;

package/src/urlJoin.js

@@ -9,7 +9,9 @@ import path from 'path';
  */
 export default function urlJoin(publicURL: string, assetPath: string): string {
   const url = URL.parse(publicURL, false, true);
-  const assetUrl = URL.parse(assetPath);
+  // Leading / ensures that paths with colons are not parsed as a protocol.
+  let p = assetPath.startsWith('/') ? assetPath : '/' + assetPath;
+  const assetUrl = URL.parse(p);
   url.pathname = path.posix.join(url.pathname, assetUrl.pathname);
   url.search = assetUrl.search;
   url.hash = assetUrl.hash;

package/test/DefaultMap.test.js

@@ -5,10 +5,13 @@ import {DefaultMap} from '../src/DefaultMap';
 
 describe('DefaultMap', () => {
   it('constructs with entries just like Map', () => {
-    let map = new DefaultMap(k => k, [
-      [1, 3],
-      [2, 27],
-    ]);
+    let map = new DefaultMap(
+      k => k,
+      [
+        [1, 3],
+        [2, 27],
+      ],
+    );
     assert.equal(map.get(1), 3);
     assert.deepEqual(Array.from(map.entries()), [
       [1, 3],

package/test/PromiseQueue.test.js

@@ -3,6 +3,7 @@ import assert from 'assert';
 import randomInt from 'random-int';
 
 import PromiseQueue from '../src/PromiseQueue';
+import sinon from 'sinon';
 
 describe('PromiseQueue', () => {
   it('run() should resolve when all async functions in queue have completed', async () => {
@@ -72,4 +73,31 @@ describe('PromiseQueue', () => {
 
     await queue.run();
   });
+
+  it('.add() should notify subscribers', async () => {
+    const queue = new PromiseQueue();
+
+    const subscribedFn = sinon.spy();
+    queue.subscribeToAdd(subscribedFn);
+
+    const promise = queue.add(() => Promise.resolve());
+    await queue.run();
+    await promise;
+
+    assert(subscribedFn.called);
+  });
+
+  it('.subscribeToAdd() should allow unsubscribing', async () => {
+    const queue = new PromiseQueue();
+
+    const subscribedFn = sinon.spy();
+    const unsubscribe = queue.subscribeToAdd(subscribedFn);
+    unsubscribe();
+
+    const promise = queue.add(() => Promise.resolve());
+    await queue.run();
+    await promise;
+
+    assert(!subscribedFn.called);
+  });
 });