@parcel/utils 2.0.0-nightly.97 → 2.0.0-nightly.982

package/lib/schema.js

@@ -3,11 +3,38 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.fuzzySearch = fuzzySearch;
 exports.default = void 0;
 
-var _diagnostic = _interopRequireWildcard(require("@parcel/diagnostic"));
+function _diagnostic() {
+  const data = _interopRequireWildcard(require("@parcel/diagnostic"));
 
-var _jsLevenshtein = _interopRequireDefault(require("js-levenshtein"));
+  _diagnostic = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+
+  _nullthrows = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _fastestLevenshtein() {
+  const data = _interopRequireDefault(require("fastest-levenshtein"));
+
+  _fastestLevenshtein = function () {
+    return data;
+  };
+
+  return data;
+}
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
@@ -15,7 +42,7 @@ function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return
 
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
-// $FlowFixMe untyped
+// flowlint-next-line untyped-import:off
 function validateSchema(schema, data) {
   function walk(schemaAncestors, dataNode, dataPath) {
     let [schemaNode] = schemaAncestors;
@@ -68,10 +95,9 @@ function validateSchema(schema, data) {
                   };
                 }
               } else if (schemaNode.__validate) {
-                let validationError = schemaNode.__validate(value); // $FlowFixMe
-
+                let validationError = schemaNode.__validate(value);
 
-                if (validationError) {
+                if (typeof validationError == 'string') {
                   return {
                     type: 'other',
                     dataType: 'value',
@@ -86,6 +112,27 @@ function validateSchema(schema, data) {
               break;
             }
 
+          case 'number':
+            {
+              // $FlowFixMe type was already checked
+              let value = 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 = [];
@@ -97,7 +144,7 @@ function validateSchema(schema, data) {
                 invalidProps = schemaNode.__forbiddenProperties.filter(val => keys.includes(val));
                 results.push(...invalidProps.map(k => ({
                   type: 'forbidden-prop',
-                  dataPath: dataPath + '/' + k,
+                  dataPath: dataPath + '/' + (0, _diagnostic().encodeJSONKeyComponent)(k),
                   dataType: 'key',
                   prop: k,
                   expectedProps: Object.keys(schemaNode.properties),
@@ -113,7 +160,7 @@ function validateSchema(schema, data) {
                 results.push(...missingKeys.map(k => ({
                   type: 'missing-prop',
                   dataPath,
-                  dataType: null,
+                  dataType: 'value',
                   prop: k,
                   expectedProps: schemaNode.required,
                   actualProps: keys,
@@ -132,7 +179,7 @@ function validateSchema(schema, data) {
                     continue;
                   } else if (k in schemaNode.properties) {
                     let result = walk([schemaNode.properties[k]].concat(schemaAncestors), // $FlowFixMe type was already checked
-                    dataNode[k], dataPath + '/' + k);
+                    dataNode[k], dataPath + '/' + (0, _diagnostic().encodeJSONKeyComponent)(k));
                     if (result) results.push(result);
                   } else {
                     if (typeof additionalProperties === 'boolean') {
@@ -140,7 +187,7 @@ function validateSchema(schema, data) {
                         results.push({
                           type: 'enum',
                           dataType: 'key',
-                          dataPath: dataPath + '/' + k,
+                          dataPath: dataPath + '/' + (0, _diagnostic().encodeJSONKeyComponent)(k),
                           expectedValues: Object.keys(schemaNode.properties).filter( // $FlowFixMe type was already checked
                           p => !(p in dataNode)),
                           actualValue: k,
@@ -150,7 +197,7 @@ function validateSchema(schema, data) {
                       }
                     } else {
                       let result = walk([additionalProperties].concat(schemaAncestors), // $FlowFixMe type was already checked
-                      dataNode[k], dataPath + '/' + k);
+                      dataNode[k], dataPath + '/' + (0, _diagnostic().encodeJSONKeyComponent)(k));
                       if (result) results.push(result);
                     }
                   }
@@ -222,18 +269,26 @@ var _default = validateSchema;
 exports.default = _default;
 
 function fuzzySearch(expectedValues, actualValue) {
-  let result = expectedValues.map(exp => [exp, (0, _jsLevenshtein.default)(exp, actualValue)]).filter( // Remove if more than half of the string would need to be changed
+  let result = expectedValues.map(exp => [exp, _fastestLevenshtein().default.distance(exp, actualValue)]).filter( // Remove if more than half of the string would need to be changed
   ([, d]) => d * 2 < actualValue.length);
   result.sort(([, a], [, b]) => a - b);
   return result.map(([v]) => v);
 }
 
-validateSchema.diagnostic = function (schema, data, dataContentsPath, dataContents, origin, prependKey, message) {
-  let errors = validateSchema(schema, data);
+validateSchema.diagnostic = function (schema, data, origin, message) {
+  var _data$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 = data.data) !== null && _data$data !== void 0 ? _data$data : JSON.parse(data.source);
+  let errors = validateSchema(schema, object);
 
   if (errors.length) {
-    let dataContentsString = typeof dataContents === 'string' ? dataContents : // $FlowFixMe
-    JSON.stringify(dataContents, null, '\t');
+    var _data$filePath;
+
     let keys = errors.map(e => {
       let message;
 
@@ -272,8 +327,8 @@ validateSchema.diagnostic = function (schema, data, dataContentsPath, dataConten
         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}`;
@@ -294,26 +349,42 @@ validateSchema.diagnostic = function (schema, data, dataContentsPath, dataConten
         message
       };
     });
-    let codeFrame = {
-      code: dataContentsString,
-      codeHighlights: (0, _diagnostic.generateJSONCodeHighlights)(dataContentsString, keys.map(({
+    let map, code;
+
+    if (data.map) {
+      map = data.map;
+      code = data.source;
+    } else {
+      var _data$source;
+
+      // $FlowFixMe we can assume that data is valid JSON
+      map = (_data$source = data.source) !== null && _data$source !== void 0 ? _data$source : JSON.stringify((0, _nullthrows().default)(data.data), 0, '\t');
+      code = map;
+    }
+
+    let codeFrames = [{
+      filePath: (_data$filePath = data.filePath) !== null && _data$filePath !== void 0 ? _data$filePath : undefined,
+      language: 'json',
+      code,
+      codeHighlights: (0, _diagnostic().generateJSONCodeHighlights)(map, keys.map(({
         key,
         type,
         message
-      }) => ({
-        key: prependKey + key,
-        type: type,
-        message
-      })))
-    };
-    throw new _diagnostic.default({
+      }) => {
+        var _data$prependKey;
+
+        return {
+          key: ((_data$prependKey = data.prependKey) !== null && _data$prependKey !== void 0 ? _data$prependKey : '') + key,
+          type: type,
+          message: message != null ? (0, _diagnostic().escapeMarkdown)(message) : message
+        };
+      }))
+    }];
+    throw new (_diagnostic().default)({
       diagnostic: {
-        message,
+        message: message,
         origin,
-        // $FlowFixMe should be a sketchy string check
-        filePath: dataContentsPath || undefined,
-        language: 'json',
-        codeFrame
+        codeFrames
       }
     });
   }

package/lib/shared-buffer.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SharedBuffer = void 0;
+
+/* global MessageChannel:readonly */
+let SharedBuffer; // $FlowFixMe[prop-missing]
+
+exports.SharedBuffer = SharedBuffer;
+
+if (process.browser) {
+  exports.SharedBuffer = 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));
+      exports.SharedBuffer = SharedBuffer = SharedArrayBuffer;
+    } catch (_) {// NOOP
+    }
+
+    channel.port1.close();
+    channel.port2.close();
+  }
+} else {
+  exports.SharedBuffer = SharedBuffer = SharedArrayBuffer;
+}

package/lib/sourcemap.js

@@ -0,0 +1,147 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.matchSourceMappingURL = matchSourceMappingURL;
+exports.loadSourceMapUrl = loadSourceMapUrl;
+exports.loadSourceMap = loadSourceMap;
+exports.remapSourceLocation = remapSourceLocation;
+exports.SOURCEMAP_EXTENSIONS = exports.SOURCEMAP_RE = void 0;
+
+function _sourceMap() {
+  const data = _interopRequireDefault(require("@parcel/source-map"));
+
+  _sourceMap = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+
+  _path = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _path2 = require("./path");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const SOURCEMAP_RE = /(?:\/\*|\/\/)\s*[@#]\s*sourceMappingURL\s*=\s*([^\s*]+)(?:\s*\*\/)?\s*$/;
+exports.SOURCEMAP_RE = SOURCEMAP_RE;
+const DATA_URL_RE = /^data:[^;]+(?:;charset=[^;]+)?;base64,(.*)/;
+const SOURCEMAP_EXTENSIONS = new Set(['css', 'es', 'es6', 'js', 'jsx', 'mjs', 'ts', 'tsx']);
+exports.SOURCEMAP_EXTENSIONS = SOURCEMAP_EXTENSIONS;
+
+function matchSourceMappingURL(contents) {
+  return contents.match(SOURCEMAP_RE);
+}
+
+async function loadSourceMapUrl(fs, filename, contents) {
+  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 = (0, _path2.isAbsolute)(mapFilePath) ? mapFilePath : _path().default.join(_path().default.dirname(filename), mapFilePath);
+    }
+
+    return {
+      url,
+      filename: mapFilePath,
+      map: JSON.parse(dataURLMatch ? Buffer.from(dataURLMatch[1], 'base64').toString() : await fs.readFile(mapFilePath, 'utf8'))
+    };
+  }
+}
+
+async function loadSourceMap(filename, contents, options) {
+  let foundMap = await loadSourceMapUrl(options.fs, filename, contents);
+
+  if (foundMap) {
+    let mapSourceRoot = _path().default.dirname(filename);
+
+    if (foundMap.map.sourceRoot && !(0, _path2.normalizeSeparators)(foundMap.map.sourceRoot).startsWith('/')) {
+      mapSourceRoot = _path().default.join(mapSourceRoot, foundMap.map.sourceRoot);
+    }
+
+    let sourcemapInstance = new (_sourceMap().default)(options.projectRoot);
+    sourcemapInstance.addVLQMap({ ...foundMap.map,
+      sources: foundMap.map.sources.map(s => {
+        return _path().default.join(mapSourceRoot, s);
+      })
+    });
+    return sourcemapInstance;
+  }
+}
+
+function remapSourceLocation(loc, originalMap) {
+  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 !== null && start !== void 0 && start.original) {
+    if (start.source) {
+      filePath = start.source;
+    }
+
+    ({
+      line: startLine,
+      column: startCol
+    } = start.original);
+    startCol++; // source map columns are 0-based
+  }
+
+  if (end !== null && end !== void 0 && 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/lib/stream.js

@@ -7,8 +7,18 @@ exports.measureStreamLength = measureStreamLength;
 exports.readableFromStringOrBuffer = readableFromStringOrBuffer;
 exports.bufferStream = bufferStream;
 exports.blobToStream = blobToStream;
+exports.streamFromPromise = streamFromPromise;
+exports.fallbackStream = fallbackStream;
 
-var _stream = require("stream");
+function _stream() {
+  const data = require("stream");
+
+  _stream = function () {
+    return data;
+  };
+
+  return data;
+}
 
 function measureStreamLength(stream) {
   return new Promise((resolve, reject) => {
@@ -23,7 +33,7 @@ function measureStreamLength(stream) {
 
 function readableFromStringOrBuffer(str) {
   // https://stackoverflow.com/questions/12755997/how-to-create-streams-from-string-in-node-js
-  const stream = new _stream.Readable();
+  const stream = new (_stream().Readable)();
   stream.push(str);
   stream.push(null);
   return stream;
@@ -43,9 +53,34 @@ function bufferStream(stream) {
 }
 
 function blobToStream(blob) {
-  if (blob instanceof _stream.Readable) {
+  if (blob instanceof _stream().Readable) {
     return blob;
   }
 
   return readableFromStringOrBuffer(blob);
+}
+
+function streamFromPromise(promise) {
+  const stream = new (_stream().PassThrough)();
+  promise.then(blob => {
+    if (blob instanceof _stream().Readable) {
+      blob.pipe(stream);
+    } else {
+      stream.end(blob);
+    }
+  });
+  return stream;
+}
+
+function fallbackStream(stream, fallback) {
+  const res = new (_stream().PassThrough)();
+  stream.on('error', err => {
+    if (err.code === 'ENOENT') {
+      fallback().pipe(res);
+    } else {
+      res.emit('error', err);
+    }
+  });
+  stream.pipe(res);
+  return res;
 }

package/lib/urlJoin.js

@@ -5,9 +5,25 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = urlJoin;
 
-var _url = _interopRequireDefault(require("url"));
+function _url() {
+  const data = _interopRequireDefault(require("url"));
 
-var _path = _interopRequireDefault(require("path"));
+  _url = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+
+  _path = function () {
+    return data;
+  };
+
+  return data;
+}
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
@@ -16,12 +32,15 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * e.g. from \path\to\res.js to /path/to/res.js.
  */
 function urlJoin(publicURL, assetPath) {
-  const url = _url.default.parse(publicURL, false, true);
+  const url = _url().default.parse(publicURL, false, true); // Leading / ensures that paths with colons are not parsed as a protocol.
+
+
+  let p = assetPath.startsWith('/') ? assetPath : '/' + assetPath;
 
-  const assetUrl = _url.default.parse(assetPath);
+  const assetUrl = _url().default.parse(p);
 
-  url.pathname = _path.default.posix.join(url.pathname, assetUrl.pathname);
+  url.pathname = _path().default.posix.join(url.pathname, assetUrl.pathname);
   url.search = assetUrl.search;
   url.hash = assetUrl.hash;
-  return _url.default.format(url);
+  return _url().default.format(url);
 }

package/package.json

@@ -1,11 +1,15 @@
 {
   "name": "@parcel/utils",
-  "version": "2.0.0-nightly.97+a63f3fc9",
+  "version": "2.0.0-nightly.982+4745cd30",
   "description": "Blazing fast, zero configuration web application bundler",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
   },
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/parcel"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/parcel-bundler/parcel.git"
@@ -13,32 +17,39 @@
   "main": "lib/index.js",
   "source": "src/index.js",
   "engines": {
-    "node": ">= 10.0.0"
+    "node": ">= 12.0.0"
   },
   "dependencies": {
     "@iarna/toml": "^2.2.0",
-    "@parcel/codeframe": "2.0.0-nightly.97+a63f3fc9",
-    "@parcel/diagnostic": "2.0.0-nightly.97+a63f3fc9",
-    "@parcel/logger": "2.0.0-nightly.97+a63f3fc9",
-    "@parcel/markdown-ansi": "2.0.0-nightly.97+a63f3fc9",
-    "ansi-html": "^0.0.7",
-    "chalk": "^2.4.2",
+    "@parcel/codeframe": "2.0.0-nightly.982+4745cd30",
+    "@parcel/diagnostic": "2.0.0-nightly.982+4745cd30",
+    "@parcel/hash": "2.2.1-nightly.2605+4745cd30",
+    "@parcel/logger": "2.0.0-nightly.982+4745cd30",
+    "@parcel/markdown-ansi": "2.0.0-nightly.982+4745cd30",
+    "@parcel/source-map": "^2.0.0",
+    "ansi-html-community": "0.0.8",
+    "chalk": "^4.1.0",
     "clone": "^2.1.1",
-    "fast-glob": "^3.0.4",
+    "fast-glob": "3.1.1",
+    "fastest-levenshtein": "^1.0.8",
     "is-glob": "^4.0.0",
     "is-url": "^1.2.2",
-    "js-levenshtein": "^1.1.6",
     "json5": "^1.0.1",
-    "micromatch": "^4.0.2",
-    "node-forge": "^0.8.1",
+    "lru-cache": "^6.0.0",
+    "micromatch": "^4.0.4",
+    "node-forge": "^1.2.1",
     "nullthrows": "^1.1.1",
-    "resolve": "^1.12.0",
-    "serialize-to-js": "^3.0.1",
-    "terser": "^3.7.3"
+    "open": "^7.0.3",
+    "terminal-link": "^2.1.1"
   },
   "devDependencies": {
     "@babel/plugin-transform-flow-strip-types": "^7.2.0",
     "random-int": "^1.0.0"
   },
-  "gitHead": "a63f3fc9726483219412920faeb255e035f90747"
+  "browser": {
+    "./src/generateCertificate.js": false,
+    "./src/http-server.js": false,
+    "./src/openInBrowser.js": false
+  },
+  "gitHead": "4745cd3023f8d5a5adcf9e565d5b82d1418dc262"
 }

package/src/DefaultMap.js

@@ -24,7 +24,7 @@ export class DefaultMap<K, V> extends Map<K, V> {
 
 // Duplicated from DefaultMap implementation for Flow
 // Roughly mirrors https://github.com/facebook/flow/blob/2eb5a78d92c167117ba9caae070afd2b9f598599/lib/core.js#L617
-export class DefaultWeakMap<K: {...}, V> extends WeakMap<K, V> {
+export class DefaultWeakMap<K: interface {}, V> extends WeakMap<K, V> {
   _getDefault: K => V;
 
   constructor(getDefault: K => V, entries?: Iterable<[K, V]>) {

package/src/PromiseQueue.js

@@ -10,6 +10,7 @@ export default class PromiseQueue<T> {
   _numRunning: number = 0;
   _queue: Array<() => Promise<void>> = [];
   _runPromise: ?Promise<Array<T>> = null;
+  _error: mixed;
   _count: number = 0;
   _results: Array<T> = [];
 
@@ -74,7 +75,7 @@ export default class PromiseQueue<T> {
     if (this._queue.length) {
       this._next();
     } else if (this._numRunning === 0) {
-      this._resolve();
+      this._done();
     }
   }
 
@@ -82,10 +83,15 @@ export default class PromiseQueue<T> {
     this._numRunning++;
     try {
       await fn();
-      this._numRunning--;
     } catch (e) {
-      this._reject(e);
-      // rejecting resets state so numRunning is reset to 0 here
+      // Only store the first error that occurs.
+      // We don't reject immediately so that any other concurrent
+      // requests have time to complete.
+      if (this._error == null) {
+        this._error = e;
+      }
+    } finally {
+      this._numRunning--;
     }
   }
 
@@ -98,17 +104,15 @@ export default class PromiseQueue<T> {
     this._deferred = null;
   }
 
-  _reject(err: mixed): void {
+  _done(): void {
     if (this._deferred != null) {
-      this._deferred.reject(err);
+      if (this._error != null) {
+        this._deferred.reject(this._error);
+      } else {
+        this._deferred.resolve(this._results);
+      }
     }
-    this._resetState();
-  }
 
-  _resolve(): void {
-    if (this._deferred != null) {
-      this._deferred.resolve(this._results);
-    }
     this._resetState();
   }
 }