@parcel/utils 2.0.0-nightly.137 → 2.0.0-nightly.1373

package/test/sourcemap.test.js

@@ -0,0 +1,207 @@
+import assert from 'assert';
+import {
+  matchSourceMappingURL,
+  loadSourceMapUrl,
+  loadSourceMap,
+} from '../src/sourcemap';
+import {NodeFS} from '@parcel/fs';
+import path from 'path';
+
+const fs = new NodeFS();
+
+describe('loadSourceMap', () => {
+  it('should not match sourceMappingURL when not at the end of the bundle', () => {
+    // Code example taken from livescript.js (issue #2408 in parcel-bundler)
+    // This snippet lead to JSAsset.js being mislead and incorrectly trying to
+    // load (due to false-positive match) sourcemap before fix was introduced
+    let code = fs.readFileSync(
+      path.join(__dirname, './input/sourcemap/no-sourcemap.js'),
+      'utf-8',
+    );
+
+    assert(!matchSourceMappingURL(code));
+  });
+
+  it('should match referenced-min sourceMappingURL when correctly inserted at end of the bundle', () => {
+    let code = fs.readFileSync(
+      path.join(__dirname, './input/sourcemap/referenced-min.js'),
+      'utf-8',
+    );
+
+    assert(!!matchSourceMappingURL(code));
+  });
+
+  it('should match inline sourceMappingURL when correctly inserted at end of the bundle', () => {
+    // inline source map taken from https://github.com/thlorenz/inline-source-map
+    let code = fs.readFileSync(
+      path.join(__dirname, './input/sourcemap/inline.js'),
+      'utf-8',
+    );
+
+    assert(!!matchSourceMappingURL(code));
+  });
+
+  it('Should be able to load sourcemap data from a url reference', async () => {
+    let filename = path.join(__dirname, './input/sourcemap/referenced-min.js');
+    let contents = fs.readFileSync(filename, 'utf-8');
+
+    let foundMap = await loadSourceMapUrl(fs, filename, contents);
+    assert.equal(foundMap.url, 'file://referenced-min.js.map');
+    assert.equal(
+      foundMap.filename,
+      path.join(__dirname, 'input/sourcemap/referenced-min.js.map'),
+    );
+    assert.deepEqual(foundMap.map, {
+      version: 3,
+      sources: ['./referenced.js'],
+      names: ['hello', 'l', 'o', 'console', 'log'],
+      mappings:
+        'AAAA,SAASA,QACP,IAAIC,EAAI,QACNC,EAAI,QACNC,QAAQC,IAAIH,EAAI,IAAMC,EAAI,KAE5BF',
+    });
+  });
+
+  it('Should be able to load sourcemap data from an inline url reference', async () => {
+    let filename = path.join(__dirname, './input/sourcemap/inline.js');
+    let contents = fs.readFileSync(filename, 'utf-8');
+
+    let foundMap = await loadSourceMapUrl(fs, filename, contents);
+    assert.equal(
+      foundMap.url,
+      'data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiIiwic291cmNlcyI6WyJmb28uanMiLCJiYXIuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7O1VBQ0c7Ozs7Ozs7Ozs7Ozs7O3NCQ0RIO3NCQUNBIn0=',
+    );
+    assert.equal(foundMap.filename, filename);
+    assert.deepEqual(foundMap.map, {
+      version: 3,
+      file: '',
+      sources: ['foo.js', 'bar.js'],
+      names: [],
+      mappings: ';;;;;;;;;UACG;;;;;;;;;;;;;;sBCDH;sBACA',
+    });
+  });
+
+  it('Should be able to load a SourceMap instance from a file', async () => {
+    let filename = path.join(__dirname, './input/sourcemap/referenced-min.js');
+    let contents = fs.readFileSync(filename, 'utf-8');
+
+    let map = await loadSourceMap(filename, contents, {
+      fs,
+      projectRoot: __dirname,
+    });
+
+    assert(!!map);
+
+    let parsedMap = map.getMap();
+    assert.deepEqual(parsedMap.sources, ['input/sourcemap/referenced.js']);
+    assert.deepEqual(parsedMap.names, ['hello', 'l', 'o', 'console', 'log']);
+    assert.deepEqual(parsedMap.mappings, [
+      {
+        generated: {line: 1, column: 0},
+        original: {line: 1, column: 0},
+        source: 0,
+      },
+      {
+        generated: {line: 1, column: 9},
+        original: {line: 1, column: 9},
+        source: 0,
+        name: 0,
+      },
+      {
+        generated: {line: 1, column: 17},
+        original: {line: 2, column: 2},
+        source: 0,
+      },
+      {
+        generated: {line: 1, column: 21},
+        original: {line: 2, column: 6},
+        source: 0,
+        name: 1,
+      },
+      {
+        generated: {line: 1, column: 23},
+        original: {line: 2, column: 10},
+        source: 0,
+      },
+      {
+        generated: {line: 1, column: 31},
+        original: {line: 3, column: 4},
+        source: 0,
+        name: 2,
+      },
+      {
+        generated: {line: 1, column: 33},
+        original: {line: 3, column: 8},
+        source: 0,
+      },
+      {
+        generated: {line: 1, column: 41},
+        original: {line: 4, column: 2},
+        source: 0,
+        name: 3,
+      },
+      {
+        generated: {line: 1, column: 49},
+        original: {line: 4, column: 10},
+        source: 0,
+        name: 4,
+      },
+      {
+        generated: {line: 1, column: 53},
+        original: {line: 4, column: 14},
+        source: 0,
+        name: 1,
+      },
+      {
+        generated: {line: 1, column: 55},
+        original: {line: 4, column: 18},
+        source: 0,
+      },
+      {
+        generated: {line: 1, column: 59},
+        original: {line: 4, column: 24},
+        source: 0,
+        name: 2,
+      },
+      {
+        generated: {line: 1, column: 61},
+        original: {line: 4, column: 28},
+        source: 0,
+      },
+      {
+        generated: {line: 1, column: 66},
+        original: {line: 6, column: 0},
+        source: 0,
+        name: 0,
+      },
+    ]);
+  });
+
+  it('Should remap sources when using sourceRoot', async () => {
+    let filename = path.join(__dirname, './input/sourcemap/referenced-min.js');
+    let contents = fs.readFileSync(filename, 'utf-8');
+
+    let map = await loadSourceMap(filename, contents, {
+      fs,
+      projectRoot: __dirname,
+    });
+
+    assert(!!map);
+
+    let parsedMap = map.getMap();
+    assert.deepEqual(parsedMap.sources, ['input/sourcemap/referenced.js']);
+  });
+
+  it('Should remap sources when using sourceRoot', async () => {
+    let filename = path.join(__dirname, './input/sourcemap/source-root.js');
+    let contents = fs.readFileSync(filename, 'utf-8');
+
+    let map = await loadSourceMap(filename, contents, {
+      fs,
+      projectRoot: __dirname,
+    });
+
+    assert(!!map);
+
+    let parsedMap = map.getMap();
+    assert.deepEqual(parsedMap.sources, ['input/source.js']);
+  });
+});

package/test/throttle.test.js

@@ -1,7 +1,6 @@
 // @flow strict-local
 
 import assert from 'assert';
-// $FlowFixMe
 import sinon from 'sinon';
 import throttle from '../src/throttle';
 
@@ -35,7 +34,7 @@ describe('throttle', () => {
 
   it('preserves the `this` when throttled functions are invoked', () => {
     let result;
-    let throttled = throttle(function() {
+    let throttled = throttle(function () {
       result = this.bar;
     }, 100);
 

package/test/urlJoin.test.js

@@ -0,0 +1,37 @@
+// @flow strict-local
+
+import assert from 'assert';
+import urlJoin from '../src/urlJoin';
+
+describe('urlJoin', () => {
+  it('Should join two paths', () => {
+    let joinedUrl = urlJoin('/', './image.jpeg?test=test');
+    assert.equal(joinedUrl, '/image.jpeg?test=test');
+  });
+
+  it('Should join two paths with longer publicUrl', () => {
+    let joinedUrl = urlJoin('/static', './image.jpeg?test=test');
+    assert.equal(joinedUrl, '/static/image.jpeg?test=test');
+  });
+
+  it('Should join two paths with longer publicUrl', () => {
+    let joinedUrl = urlJoin('/static', 'image.jpeg?test=test');
+    assert.equal(joinedUrl, '/static/image.jpeg?test=test');
+  });
+
+  it('Should turn windows path into posix', () => {
+    let joinedUrl = urlJoin('/static', '.\\image.jpeg?test=test');
+    assert.equal(joinedUrl, '/static/image.jpeg?test=test');
+  });
+
+  it('should support paths with colons', () => {
+    let joinedUrl = urlJoin('/static', 'a:b:c.html');
+    assert.equal(joinedUrl, '/static/a:b:c.html');
+
+    joinedUrl = urlJoin('/static', '/a:b:c.html');
+    assert.equal(joinedUrl, '/static/a:b:c.html');
+
+    joinedUrl = urlJoin('/static', './a:b:c.html');
+    assert.equal(joinedUrl, '/static/a:b:c.html');
+  });
+});

package/lib/DefaultMap.js

@@ -1,64 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.DefaultWeakMap = exports.DefaultMap = void 0;
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-class DefaultMap extends Map {
-  constructor(getDefault, entries) {
-    super(entries);
-
-    _defineProperty(this, "_getDefault", void 0);
-
-    this._getDefault = getDefault;
-  }
-
-  get(key) {
-    let ret;
-
-    if (this.has(key)) {
-      ret = super.get(key);
-    } else {
-      ret = this._getDefault(key);
-      this.set(key, ret);
-    } // $FlowFixMe
-
-
-    return ret;
-  }
-
-} // Duplicated from DefaultMap implementation for Flow
-// Roughly mirrors https://github.com/facebook/flow/blob/2eb5a78d92c167117ba9caae070afd2b9f598599/lib/core.js#L617
-
-
-exports.DefaultMap = DefaultMap;
-
-class DefaultWeakMap extends WeakMap {
-  constructor(getDefault, entries) {
-    super(entries);
-
-    _defineProperty(this, "_getDefault", void 0);
-
-    this._getDefault = getDefault;
-  }
-
-  get(key) {
-    let ret;
-
-    if (this.has(key)) {
-      ret = super.get(key);
-    } else {
-      ret = this._getDefault(key);
-      this.set(key, ret);
-    } // $FlowFixMe
-
-
-    return ret;
-  }
-
-}
-
-exports.DefaultWeakMap = DefaultWeakMap;

package/lib/Deferred.js

@@ -1,26 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.makeDeferredWithPromise = makeDeferredWithPromise;
-
-var _assert = _interopRequireDefault(require("assert"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function makeDeferredWithPromise() {
-  let deferred;
-  let promise = new Promise((resolve, reject) => {
-    deferred = {
-      resolve,
-      reject
-    };
-  }); // Promise constructor callback executes synchronously, so this is defined
-
-  (0, _assert.default)(deferred != null);
-  return {
-    deferred,
-    promise
-  };
-}

package/lib/PromiseQueue.js

@@ -1,133 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _Deferred = require("./Deferred");
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-class PromiseQueue {
-  constructor(opts = {
-    maxConcurrent: Infinity
-  }) {
-    _defineProperty(this, "_deferred", void 0);
-
-    _defineProperty(this, "_maxConcurrent", void 0);
-
-    _defineProperty(this, "_numRunning", 0);
-
-    _defineProperty(this, "_queue", []);
-
-    _defineProperty(this, "_runPromise", null);
-
-    _defineProperty(this, "_count", 0);
-
-    _defineProperty(this, "_results", []);
-
-    if (opts.maxConcurrent <= 0) {
-      throw new TypeError('maxConcurrent must be a positive, non-zero value');
-    }
-
-    this._maxConcurrent = opts.maxConcurrent;
-  }
-
-  getNumWaiting() {
-    return this._queue.length;
-  }
-
-  add(fn) {
-    return new Promise((resolve, reject) => {
-      let i = this._count++;
-
-      this._queue.push(() => fn().then(result => {
-        this._results[i] = result;
-        resolve(result);
-      }, err => {
-        reject(err);
-        throw err;
-      }));
-
-      if (this._numRunning > 0 && this._numRunning < this._maxConcurrent) {
-        this._next();
-      }
-    });
-  }
-
-  run() {
-    if (this._runPromise != null) {
-      return this._runPromise;
-    }
-
-    if (this._queue.length === 0) {
-      return Promise.resolve([]);
-    }
-
-    let {
-      deferred,
-      promise
-    } = (0, _Deferred.makeDeferredWithPromise)();
-    this._deferred = deferred;
-    this._runPromise = promise;
-
-    while (this._queue.length && this._numRunning < this._maxConcurrent) {
-      this._next();
-    }
-
-    return promise;
-  }
-
-  async _next() {
-    let fn = this._queue.shift();
-
-    await this._runFn(fn);
-
-    if (this._queue.length) {
-      this._next();
-    } else if (this._numRunning === 0) {
-      this._resolve();
-    }
-  }
-
-  async _runFn(fn) {
-    this._numRunning++;
-
-    try {
-      await fn();
-      this._numRunning--;
-    } catch (e) {
-      this._reject(e); // rejecting resets state so numRunning is reset to 0 here
-
-    }
-  }
-
-  _resetState() {
-    this._queue = [];
-    this._count = 0;
-    this._results = [];
-    this._runPromise = null;
-    this._numRunning = 0;
-    this._deferred = null;
-  }
-
-  _reject(err) {
-    if (this._deferred != null) {
-      this._deferred.reject(err);
-    }
-
-    this._resetState();
-  }
-
-  _resolve() {
-    if (this._deferred != null) {
-      this._deferred.resolve(this._results);
-    }
-
-    this._resetState();
-  }
-
-}
-
-exports.default = PromiseQueue;

package/lib/TapStream.js

@@ -1,41 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _stream = require("stream");
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-/*
- * "Taps" into the contents of a flowing stream, yielding chunks to the passed
- * callback. Continues to pass data chunks down the stream.
- */
-class TapStream extends _stream.Transform {
-  constructor(tap, options) {
-    super(_objectSpread({}, options));
-
-    _defineProperty(this, "_tap", void 0);
-
-    this._tap = tap;
-  }
-
-  _transform(chunk, encoding, callback) {
-    try {
-      this._tap(Buffer.from(chunk));
-
-      callback(null, chunk);
-    } catch (err) {
-      callback(err);
-    }
-  }
-
-}
-
-exports.default = TapStream;

package/lib/ansi-html.js

@@ -1,16 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.ansiHtml = ansiHtml;
-
-var _ansiHtml = _interopRequireDefault(require("ansi-html"));
-
-var _escapeHtml = require("./escape-html");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function ansiHtml(ansi) {
-  return (0, _ansiHtml.default)((0, _escapeHtml.escapeHTML)(ansi));
-}

package/lib/blob.js

@@ -1,31 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.blobToBuffer = blobToBuffer;
-exports.blobToString = blobToString;
-
-var _ = require("../");
-
-var _stream = require("stream");
-
-function blobToBuffer(blob) {
-  if (blob instanceof _stream.Readable) {
-    return (0, _.bufferStream)(blob);
-  } else if (blob instanceof Buffer) {
-    return Promise.resolve(Buffer.from(blob));
-  } else {
-    return Promise.resolve(Buffer.from(blob, 'utf8'));
-  }
-}
-
-async function blobToString(blob) {
-  if (blob instanceof _stream.Readable) {
-    return (await (0, _.bufferStream)(blob)).toString();
-  } else if (blob instanceof Buffer) {
-    return blob.toString();
-  } else {
-    return blob;
-  }
-}

package/lib/bundle-url.js

@@ -1,43 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getBaseURL = getBaseURL;
-exports.getBundleURL = void 0;
-let bundleURL = null;
-
-function getBundleURLCached() {
-  if (bundleURL == null) {
-    bundleURL = _getBundleURL();
-  }
-
-  return bundleURL;
-}
-
-function _getBundleURL() {
-  // Attempt to find the URL of the current script and use that as the base URL
-  try {
-    throw new Error();
-  } catch (err) {
-    let stack = typeof err.stack === 'string' ? err.stack : '';
-    let matches = stack.match(/(https?|file|ftp):\/\/[^)\n]+/g);
-
-    if (matches) {
-      return getBaseURL(matches[0]);
-    }
-  }
-
-  return '/';
-}
-
-function getBaseURL(url) {
-  if (url == null) {
-    return '/';
-  }
-
-  return url.replace(/^((?:https?|file|ftp):\/\/.+)\/[^/]+$/, '$1') + '/';
-}
-
-const getBundleURL = getBundleURLCached;
-exports.getBundleURL = getBundleURL;

package/lib/collection.js

@@ -1,62 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.unique = unique;
-exports.flatMap = flatMap;
-exports.objectSortedEntries = objectSortedEntries;
-exports.objectSortedEntriesDeep = objectSortedEntriesDeep;
-exports.setDifference = setDifference;
-
-function unique(array) {
-  return [...new Set(array)];
-}
-
-function flatMap(array, projectFn) {
-  let out = [];
-
-  for (let arr of array.map(projectFn)) {
-    out.push(...arr);
-  }
-
-  return out;
-}
-
-function objectSortedEntries(obj) {
-  return Object.entries(obj).sort(([keyA], [keyB]) => keyA.localeCompare(keyB));
-}
-
-function objectSortedEntriesDeep(object) {
-  let sortedEntries = objectSortedEntries(object);
-
-  for (let i = 0; i < sortedEntries.length; i++) {
-    sortedEntries[i][1] = sortEntry(sortedEntries[i][1]);
-  }
-
-  return sortedEntries;
-}
-
-function sortEntry(entry) {
-  if (Array.isArray(entry)) {
-    return entry.map(sortEntry);
-  }
-
-  if (typeof entry === 'object' && entry != null) {
-    return objectSortedEntriesDeep(entry);
-  }
-
-  return entry;
-}
-
-function setDifference(a, b) {
-  let difference = new Set();
-
-  for (let e of a) {
-    if (!b.has(e)) {
-      difference.add(e);
-    }
-  }
-
-  return difference;
-}