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

package/src/schema.js

@@ -1,15 +1,20 @@
 // @flow strict-local
 import ThrowableDiagnostic, {
   generateJSONCodeHighlights,
+  escapeMarkdown,
+  encodeJSONKeyComponent,
 } from '@parcel/diagnostic';
+import type {Mapping} from 'json-source-map';
+import nullthrows from 'nullthrows';
 // flowlint-next-line untyped-import:off
-import levenshteinDistance from 'js-levenshtein';
+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);
                   }
@@ -344,7 +369,7 @@ export function fuzzySearch(
   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,
@@ -353,22 +378,43 @@ export function fuzzySearch(
   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.source 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') {
@@ -406,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}`;
@@ -425,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,
       },
     });
   }

package/src/shared-buffer.js

@@ -0,0 +1,24 @@
+// @flow
+/* global MessageChannel:readonly */
+
+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

@@ -1,13 +1,27 @@
 // @flow
+import type {SourceLocation} from '@parcel/types';
 import type {FileSystem} from '@parcel/fs';
 import SourceMap from '@parcel/source-map';
 import path from 'path';
-import {normalizeSeparators} from './path';
+import {normalizeSeparators, isAbsolute} from './path';
 
-const SOURCEMAP_RE = /(?:\/\*|\/\/)\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',
+  'ts',
+  'tsx',
+]);
 
-export function matchSourceMappingURL(contents: string) {
+export function matchSourceMappingURL(
+  contents: string,
+): null | RegExp$matchResult {
   return contents.match(SOURCEMAP_RE);
 }
 
@@ -15,20 +29,29 @@ export async function loadSourceMapUrl(
   fs: FileSystem,
   filename: string,
   contents: string,
-) {
+): Promise<?{|filename: string, map: any, url: string|}> {
   let match = matchSourceMappingURL(contents);
   if (match) {
     let url = match[1].trim();
     let dataURLMatch = url.match(DATA_URL_RE);
-    filename = dataURLMatch ? filename : path.join(path.dirname(filename), url);
+
+    let mapFilePath;
+    if (dataURLMatch) {
+      mapFilePath = filename;
+    } else {
+      mapFilePath = url.replace(/^file:\/\//, '');
+      mapFilePath = isAbsolute(mapFilePath)
+        ? mapFilePath
+        : path.join(path.dirname(filename), mapFilePath);
+    }
 
     return {
       url,
-      filename,
+      filename: mapFilePath,
       map: JSON.parse(
         dataURLMatch
           ? Buffer.from(dataURLMatch[1], 'base64').toString()
-          : await fs.readFile(filename, 'utf8'),
+          : await fs.readFile(mapFilePath, 'utf8'),
       ),
     };
   }
@@ -49,13 +72,64 @@ export async function loadSourceMap(
       mapSourceRoot = path.join(mapSourceRoot, foundMap.map.sourceRoot);
     }
 
-    let sourcemapInstance = new SourceMap();
-    sourcemapInstance.addRawMappings({
+    let sourcemapInstance = new SourceMap(options.projectRoot);
+    sourcemapInstance.addVLQMap({
       ...foundMap.map,
       sources: foundMap.map.sources.map(s => {
-        return path.relative(options.projectRoot, path.join(mapSourceRoot, s));
+        return path.join(mapSourceRoot, s);
       }),
     });
     return sourcemapInstance;
   }
 }
+
+export function remapSourceLocation(
+  loc: SourceLocation,
+  originalMap: SourceMap,
+): SourceLocation {
+  let {
+    filePath,
+    start: {line: startLine, column: startCol},
+    end: {line: endLine, column: endCol},
+  } = loc;
+  let lineDiff = endLine - startLine;
+  let colDiff = endCol - startCol;
+  let start = originalMap.findClosestMapping(startLine, startCol);
+  let end = originalMap.findClosestMapping(endLine, endCol);
+
+  if (start?.original) {
+    if (start.source) {
+      filePath = start.source;
+    }
+
+    ({line: startLine, column: startCol} = start.original);
+    startCol++; // source map columns are 0-based
+  }
+
+  if (end?.original) {
+    ({line: endLine, column: endCol} = end.original);
+    endCol++;
+
+    if (endLine < startLine) {
+      endLine = startLine;
+      endCol = startCol;
+    } else if (endLine === startLine && endCol < startCol && lineDiff === 0) {
+      endCol = startCol + colDiff;
+    }
+  } else {
+    endLine = startLine;
+    endCol = startCol;
+  }
+
+  return {
+    filePath,
+    start: {
+      line: startLine,
+      column: startCol,
+    },
+    end: {
+      line: endLine,
+      column: endCol,
+    },
+  };
+}

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/config.test.js

@@ -0,0 +1,50 @@
+// @flow strict-local
+
+import assert from 'assert';
+import {loadConfig} from '../src/config';
+import {inputFS as fs} from '@parcel/test-utils';
+import path from 'path';
+
+describe('loadConfig', () => {
+  it('load config with json', async () => {
+    assert.deepEqual(
+      (
+        await loadConfig(
+          fs,
+          path.join(__dirname, './input/config/config.json'),
+          ['config.json'],
+          path.join(__dirname, './input/config/'),
+        )
+      )?.config,
+      {
+        hoge: 'fuga',
+      },
+    );
+  });
+
+  it('should throw error with empty string json', async () => {
+    // $FlowFixMe[prop-missing]
+    await assert.rejects(async () => {
+      await loadConfig(
+        fs,
+        path.join(__dirname, './input/config/empty.json'),
+        ['empty.json'],
+        path.join(__dirname, './input/config/'),
+      );
+    });
+  });
+
+  it('should load with empty string config toml', async () => {
+    assert.deepEqual(
+      (
+        await loadConfig(
+          fs,
+          path.join(__dirname, './input/config/empty.toml'),
+          ['empty.toml'],
+          path.join(__dirname, './input/config/'),
+        )
+      )?.config,
+      {},
+    );
+  });
+});

package/test/input/config/config.json

@@ -0,0 +1,3 @@
+{
+    "hoge": "fuga"
+}

package/test/input/sourcemap/referenced-min.js

@@ -1,2 +1,2 @@
 function hello(){var l="Hello",o="world";console.log(l+" "+o+"!")}hello();
-//# sourceMappingURL=referenced-min.js.map
+//# sourceMappingURL=file://referenced-min.js.map