@parcel/utils 2.0.0-nightly.122 → 2.0.0-nightly.1221

package/src/prettyDiagnostic.js

@@ -1,61 +1,101 @@
 // @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 =
+        typeof filePath !== 'string'
+          ? ''
+          : `${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 +104,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);
 }

package/src/replaceBundleReferences.js

@@ -1,12 +1,20 @@
 // @flow strict-local
 
 import type SourceMap from '@parcel/source-map';
-import type {Async, Blob, Bundle, BundleGraph, Dependency} from '@parcel/types';
+import type {
+  Async,
+  Blob,
+  Bundle,
+  BundleGraph,
+  Dependency,
+  NamedBundle,
+} from '@parcel/types';
 
 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 */,
@@ -15,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.
@@ -25,44 +33,55 @@ export function replaceURLReferences({
   bundleGraph,
   contents,
   map,
+  getReplacement = s => s,
   relative = true,
 }: {|
-  bundle: Bundle,
-  bundleGraph: BundleGraph,
+  bundle: NamedBundle,
+  bundleGraph: BundleGraph<NamedBundle>,
   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.specifierType === 'url') {
+      urlDependencies.push(node.value);
+    }
+  });
 
-  for (let dependency of bundleGraph.getExternalDependencies(bundle)) {
-    if (!dependency.isURL) {
+  for (let dependency of urlDependencies) {
+    if (dependency.specifierType !== 'url') {
       continue;
     }
 
-    let bundleGroup = bundleGraph.resolveExternalDependency(dependency);
-    if (bundleGroup == null) {
-      replacements.set(dependency.id, {
-        from: dependency.id,
-        to: dependency.moduleSpecifier,
+    let placeholder = dependency.meta?.placeholder ?? dependency.id;
+    invariant(typeof placeholder === 'string');
+
+    let resolved = bundleGraph.getReferencedBundle(dependency, bundle);
+    if (resolved == null) {
+      replacements.set(placeholder, {
+        from: placeholder,
+        to: getReplacement(dependency.specifier),
       });
       continue;
     }
 
-    let [entryBundle] = bundleGraph.getBundlesInBundleGroup(bundleGroup);
-    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,
+        getReplacement,
       }),
     );
   }
@@ -83,7 +102,7 @@ export async function replaceInlineReferences({
   getInlineBundleContents,
 }: {|
   bundle: Bundle,
-  bundleGraph: BundleGraph,
+  bundleGraph: BundleGraph<NamedBundle>,
   contents: string,
   getInlineReplacement: (
     Dependency,
@@ -92,20 +111,22 @@ export async function replaceInlineReferences({
   ) => {|from: string, to: string|},
   getInlineBundleContents: (
     Bundle,
-    BundleGraph,
-  ) => Async<{|contents: Blob, map: ?(Readable | string)|}>,
+    BundleGraph<NamedBundle>,
+  ) => Async<{|contents: Blob|}>,
   map?: ?SourceMap,
 |}): Promise<{|+contents: string, +map: ?SourceMap|}> {
   let replacements = new Map();
 
-  for (let dependency of bundleGraph.getExternalDependencies(bundle)) {
-    let bundleGroup = bundleGraph.resolveExternalDependency(dependency);
-    if (bundleGroup == null) {
-      continue;
+  let dependencies = [];
+  bundle.traverse(node => {
+    if (node.type === 'dependency') {
+      dependencies.push(node.value);
     }
+  });
 
-    let [entryBundle] = bundleGraph.getBundlesInBundleGroup(bundleGroup);
-    if (!entryBundle.isInline) {
+  for (let dependency of dependencies) {
+    let entryBundle = bundleGraph.getReferencedBundle(dependency, bundle);
+    if (entryBundle?.bundleBehavior !== 'inline') {
       continue;
     }
 
@@ -113,15 +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.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),
       );
     }
@@ -130,32 +154,52 @@ export async function replaceInlineReferences({
   return performReplacement(replacements, contents, map);
 }
 
-function getURLReplacement({
+export function getURLReplacement({
   dependency,
   fromBundle,
   toBundle,
   relative,
+  getReplacement,
 }: {|
   dependency: Dependency,
-  fromBundle: Bundle,
-  toBundle: Bundle,
+  fromBundle: NamedBundle,
+  toBundle: NamedBundle,
   relative: boolean,
-|}) {
-  let url = URL.parse(dependency.moduleSpecifier);
+  getReplacement?: string => string,
+|}): {|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,
-    to,
+    from: placeholder,
+    to: getReplacement ? getReplacement(to) : to,
   };
 }
 

package/src/schema.js

@@ -1,15 +1,20 @@
 // @flow strict-local
 import ThrowableDiagnostic, {
   generateJSONCodeHighlights,
+  escapeMarkdown,
+  encodeJSONKeyComponent,
 } from '@parcel/diagnostic';
-// $FlowFixMe untyped
-import levenshteinDistance from 'js-levenshtein';
+import type {Mapping} from '@mischnic/json-sourcemap';
+import nullthrows from 'nullthrows';
+// flowlint-next-line untyped-import:off
+import levenshtein from 'fastest-levenshtein';
 
 export type SchemaEntity =
   | SchemaObject
   | SchemaArray
   | SchemaBoolean
   | SchemaString
+  | SchemaNumber
   | SchemaEnum
   | SchemaOneOf
   | SchemaAllOf
@@ -40,6 +45,11 @@ export type SchemaString = {|
   __validate?: (val: string) => ?string,
   __type?: string,
 |};
+export type SchemaNumber = {|
+  type: 'number',
+  enum?: Array<number>,
+  __type?: string,
+|};
 export type SchemaEnum = {|
   enum: Array<mixed>,
 |};
@@ -88,7 +98,7 @@ export type SchemaError =
       prop: string,
       expectedProps: Array<string>,
       actualProps: Array<string>,
-      dataType: null | 'key',
+      dataType: 'key' | 'value',
 
       dataPath: string,
       ancestors: Array<SchemaEntity>,
@@ -99,7 +109,6 @@ export type SchemaError =
       actualValue: mixed,
       dataType: ?'key' | 'value',
       message?: string,
-
       dataPath: string,
       ancestors: Array<SchemaEntity>,
     |};
@@ -159,8 +168,7 @@ function validateSchema(schema: SchemaEntity, data: mixed): Array<SchemaError> {
               }
             } else if (schemaNode.__validate) {
               let validationError = schemaNode.__validate(value);
-              // $FlowFixMe
-              if (validationError) {
+              if (typeof validationError == 'string') {
                 return {
                   type: 'other',
                   dataType: 'value',
@@ -173,6 +181,23 @@ function validateSchema(schema: SchemaEntity, data: mixed): Array<SchemaError> {
             }
             break;
           }
+          case 'number': {
+            // $FlowFixMe type was already checked
+            let value: number = dataNode;
+            if (schemaNode.enum) {
+              if (!schemaNode.enum.includes(value)) {
+                return {
+                  type: 'enum',
+                  dataType: 'value',
+                  dataPath,
+                  expectedValues: schemaNode.enum,
+                  actualValue: value,
+                  ancestors: schemaAncestors,
+                };
+              }
+            }
+            break;
+          }
           case 'object': {
             let results: Array<Array<SchemaError> | SchemaError> = [];
             let invalidProps;
@@ -187,7 +212,7 @@ function validateSchema(schema: SchemaEntity, data: mixed): Array<SchemaError> {
                   k =>
                     ({
                       type: 'forbidden-prop',
-                      dataPath: dataPath + '/' + k,
+                      dataPath: dataPath + '/' + encodeJSONKeyComponent(k),
                       dataType: 'key',
                       prop: k,
                       expectedProps: Object.keys(schemaNode.properties),
@@ -209,7 +234,7 @@ function validateSchema(schema: SchemaEntity, data: mixed): Array<SchemaError> {
                     ({
                       type: 'missing-prop',
                       dataPath,
-                      dataType: null,
+                      dataType: 'value',
                       prop: k,
                       expectedProps: schemaNode.required,
                       actualProps: keys,
@@ -230,7 +255,7 @@ function validateSchema(schema: SchemaEntity, data: mixed): Array<SchemaError> {
                     [schemaNode.properties[k]].concat(schemaAncestors),
                     // $FlowFixMe type was already checked
                     dataNode[k],
-                    dataPath + '/' + k,
+                    dataPath + '/' + encodeJSONKeyComponent(k),
                   );
                   if (result) results.push(result);
                 } else {
@@ -239,7 +264,7 @@ function validateSchema(schema: SchemaEntity, data: mixed): Array<SchemaError> {
                       results.push({
                         type: 'enum',
                         dataType: 'key',
-                        dataPath: dataPath + '/' + k,
+                        dataPath: dataPath + '/' + encodeJSONKeyComponent(k),
                         expectedValues: Object.keys(
                           schemaNode.properties,
                         ).filter(
@@ -256,7 +281,7 @@ function validateSchema(schema: SchemaEntity, data: mixed): Array<SchemaError> {
                       [additionalProperties].concat(schemaAncestors),
                       // $FlowFixMe type was already checked
                       dataNode[k],
-                      dataPath + '/' + k,
+                      dataPath + '/' + encodeJSONKeyComponent(k),
                     );
                     if (result) results.push(result);
                   }
@@ -339,9 +364,12 @@ function validateSchema(schema: SchemaEntity, data: mixed): Array<SchemaError> {
 }
 export default validateSchema;
 
-function fuzzySearch(expectedValues: Array<string>, actualValue: string) {
+export function fuzzySearch(
+  expectedValues: Array<string>,
+  actualValue: string,
+): Array<string> {
   let result = expectedValues
-    .map(exp => [exp, levenshteinDistance(exp, actualValue)])
+    .map(exp => [exp, levenshtein.distance(exp, actualValue)])
     .filter(
       // Remove if more than half of the string would need to be changed
       ([, d]) => d * 2 < actualValue.length,
@@ -350,22 +378,43 @@ function fuzzySearch(expectedValues: Array<string>, actualValue: string) {
   return result.map(([v]) => v);
 }
 
-validateSchema.diagnostic = function(
+validateSchema.diagnostic = function (
   schema: SchemaEntity,
-  data: mixed,
-  dataContentsPath?: ?string,
-  dataContents: string | mixed,
+  data: {|
+    ...
+      | {|
+          source?: ?string,
+          data?: mixed,
+        |}
+      | {|
+          source: string,
+          map: {|
+            data: mixed,
+            pointers: {|[key: string]: Mapping|},
+          |},
+        |},
+    filePath?: ?string,
+    prependKey?: ?string,
+  |},
   origin: string,
-  prependKey: string,
   message: string,
 ): void {
-  let errors = validateSchema(schema, data);
+  if (
+    'source' in data &&
+    'data' in data &&
+    typeof data.source !== 'string' &&
+    !data
+  ) {
+    throw new Error(
+      'At least one of data.source and data.data must be defined!',
+    );
+  }
+  let object = data.map
+    ? data.map.data
+    : // $FlowFixMe we can assume it's a JSON object
+      data.data ?? JSON.parse(data.source);
+  let errors = validateSchema(schema, object);
   if (errors.length) {
-    let dataContentsString: string =
-      typeof dataContents === 'string'
-        ? dataContents
-        : // $FlowFixMe
-          JSON.stringify(dataContents, null, '\t');
     let keys = errors.map(e => {
       let message;
       if (e.type === 'enum') {
@@ -403,10 +452,8 @@ validateSchema.diagnostic = function(
         let {prop, actualProps} = e;
         let likely = fuzzySearch(actualProps, prop);
         if (likely.length > 0) {
-          message = `Did you mean ${likely
-            .map(v => JSON.stringify(v))
-            .join(', ')}?`;
-          e.dataPath += '/' + prop;
+          message = `Did you mean ${JSON.stringify(prop)}?`;
+          e.dataPath += '/' + likely[0];
           e.dataType = 'key';
         } else {
           message = `Missing property ${prop}`;
@@ -422,26 +469,36 @@ validateSchema.diagnostic = function(
       }
       return {key: e.dataPath, type: e.dataType, message};
     });
-    let codeFrame = {
-      code: dataContentsString,
-      codeHighlights: generateJSONCodeHighlights(
-        dataContentsString,
-        keys.map(({key, type, message}) => ({
-          key: prependKey + key,
-          type: type,
-          message,
-        })),
-      ),
-    };
+    let map, code;
+    if (data.map) {
+      map = data.map;
+      code = data.source;
+    } else {
+      // $FlowFixMe we can assume that data is valid JSON
+      map = data.source ?? JSON.stringify(nullthrows(data.data), 0, '\t');
+      code = map;
+    }
+    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: message,
         origin,
-        // $FlowFixMe should be a sketchy string check
-        filePath: dataContentsPath || undefined,
-        language: 'json',
-        codeFrame,
+        codeFrames,
       },
     });
   }