@parcel/utils 2.0.0-nightly.127 → 2.0.0-nightly.1274

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,
       },
     });
   }

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

@@ -0,0 +1,135 @@
+// @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, isAbsolute} from './path';
+
+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,
+): null | RegExp$matchResult {
+  return contents.match(SOURCEMAP_RE);
+}
+
+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);
+
+    let mapFilePath;
+    if (dataURLMatch) {
+      mapFilePath = filename;
+    } else {
+      mapFilePath = url.replace(/^file:\/\//, '');
+      mapFilePath = isAbsolute(mapFilePath)
+        ? mapFilePath
+        : path.join(path.dirname(filename), mapFilePath);
+    }
+
+    return {
+      url,
+      filename: mapFilePath,
+      map: JSON.parse(
+        dataURLMatch
+          ? Buffer.from(dataURLMatch[1], 'base64').toString()
+          : await fs.readFile(mapFilePath, 'utf8'),
+      ),
+    };
+  }
+}
+
+export async function loadSourceMap(
+  filename: string,
+  contents: string,
+  options: {fs: FileSystem, projectRoot: string, ...},
+): Promise<?SourceMap> {
+  let foundMap = await loadSourceMapUrl(options.fs, filename, contents);
+  if (foundMap) {
+    let mapSourceRoot = path.dirname(filename);
+    if (
+      foundMap.map.sourceRoot &&
+      !normalizeSeparators(foundMap.map.sourceRoot).startsWith('/')
+    ) {
+      mapSourceRoot = path.join(mapSourceRoot, foundMap.map.sourceRoot);
+    }
+
+    let sourcemapInstance = new SourceMap(options.projectRoot);
+    sourcemapInstance.addVLQMap({
+      ...foundMap.map,
+      sources: foundMap.map.sources.map(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/stream.js

@@ -1,6 +1,6 @@
 // @flow strict-local
 
-import {Readable} from 'stream';
+import {Readable, PassThrough} from 'stream';
 import type {Blob} from '@parcel/types';
 
 export function measureStreamLength(stream: Readable): Promise<number> {
@@ -42,3 +42,33 @@ export function blobToStream(blob: Blob): Readable {
 
   return readableFromStringOrBuffer(blob);
 }
+
+export function streamFromPromise(promise: Promise<Blob>): Readable {
+  const stream = new PassThrough();
+  promise.then(blob => {
+    if (blob instanceof Readable) {
+      blob.pipe(stream);
+    } else {
+      stream.end(blob);
+    }
+  });
+
+  return stream;
+}
+
+export function fallbackStream(
+  stream: Readable,
+  fallback: () => Readable,
+): Readable {
+  const res = new PassThrough();
+  stream.on('error', err => {
+    if (err.code === 'ENOENT') {
+      fallback().pipe(res);
+    } else {
+      res.emit('error', err);
+    }
+  });
+
+  stream.pipe(res);
+  return res;
+}

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

@@ -0,0 +1,119 @@
+// @flow strict-local
+
+import assert from 'assert';
+import {BitSet} from '../src/BitSet';
+
+function assertValues<Item>(set: BitSet<Item>, values: Array<Item>) {
+  let setValues = set.values();
+
+  for (let value of values) {
+    assert(set.has(value), 'Set.has returned false');
+    assert(
+      setValues.some(v => v === value),
+      'Set values is missing value',
+    );
+  }
+
+  assert(
+    setValues.length === values.length,
+    `Expected ${values.length} values but got ${setValues.length}`,
+  );
+}
+
+describe('BitSet', () => {
+  it('cloneEmpty should return an empty set', () => {
+    let set1 = BitSet.from([1, 2, 3, 4, 5]);
+    set1.add(1);
+    set1.add(3);
+
+    let set2 = set1.cloneEmpty();
+
+    assertValues(set2, []);
+  });
+
+  it('clone should return a set with the same values', () => {
+    let set1 = BitSet.from([1, 2, 3, 4, 5]);
+    set1.add(1);
+    set1.add(3);
+
+    let set2 = set1.clone();
+
+    assertValues(set2, [1, 3]);
+  });
+
+  it('clear should remove all values from the set', () => {
+    let set1 = BitSet.from([1, 2, 3, 4, 5]);
+    set1.add(1);
+    set1.add(3);
+
+    set1.clear();
+
+    assertValues(set1, []);
+  });
+
+  it('delete should remove values from the set', () => {
+    let set1 = BitSet.from([1, 2, 3, 4, 5]);
+    set1.add(1);
+    set1.add(3);
+    set1.add(5);
+
+    set1.delete(3);
+
+    assertValues(set1, [1, 5]);
+  });
+
+  it('should intersect with another BitSet', () => {
+    let set1 = BitSet.from([1, 2, 3, 4, 5]);
+    set1.add(1);
+    set1.add(3);
+
+    let set2 = set1.cloneEmpty();
+    set2.add(3);
+    set2.add(5);
+
+    set1.intersect(set2);
+    assertValues(set1, [3]);
+  });
+
+  it('should union with another BitSet', () => {
+    let set1 = BitSet.from([1, 2, 3, 4, 5]);
+    set1.add(1);
+    set1.add(3);
+
+    let set2 = set1.cloneEmpty();
+    set2.add(3);
+    set2.add(5);
+
+    set1.union(set2);
+    assertValues(set1, [1, 3, 5]);
+  });
+
+  it('BitSet.union should create a new BitSet with the union', () => {
+    let set1 = BitSet.from([1, 2, 3, 4, 5]);
+    set1.add(1);
+    set1.add(3);
+
+    let set2 = set1.cloneEmpty();
+    set2.add(3);
+    set2.add(5);
+
+    let set3 = BitSet.union(set1, set2);
+    assertValues(set1, [1, 3]);
+    assertValues(set2, [3, 5]);
+    assertValues(set3, [1, 3, 5]);
+  });
+
+  it('returns an array of all values', () => {
+    let set = BitSet.from([1, 2, 3, 4]);
+    set.add(1);
+    set.add(3);
+
+    assertValues(set, [3, 1]);
+  });
+
+  it('should return an error if a new item is added', () => {
+    let set = BitSet.from([1, 2, 3, 4]);
+
+    assert.throws(() => set.add(5), /Item is missing from BitSet/);
+  });
+});

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

@@ -1,7 +1,11 @@
 // @flow
 
 import assert from 'assert';
-import {objectSortedEntries, objectSortedEntriesDeep} from '../src/collection';
+import {
+  objectSortedEntries,
+  objectSortedEntriesDeep,
+  setDifference,
+} from '../src/collection';
 
 describe('objectSortedEntries', () => {
   it('returns a sorted list of key/value tuples', () => {
@@ -38,3 +42,11 @@ describe('objectSortedEntriesDeep', () => {
     );
   });
 });
+describe('setDifference', () => {
+  it('returns a setDifference of two sets of T type', () => {
+    assert.deepEqual(
+      setDifference(new Set([1, 2, 3]), new Set([3, 4, 5])),
+      new Set([1, 2, 4, 5]),
+    );
+  });
+});