@atlaspack/utils 2.14.5-canary.24 → 2.14.5-canary.240

package/dist/shared-buffer.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharedBuffer = void 0;
+// @ts-expect-error process.browser is a browser-specific property
+if (process.browser) {
+    exports.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 = SharedArrayBuffer;
+        }
+        catch (_) {
+            // NOOP
+        }
+        channel.port1.close();
+        channel.port2.close();
+    }
+}
+else {
+    exports.SharedBuffer = SharedArrayBuffer;
+}

package/dist/sourcemap.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SOURCEMAP_EXTENSIONS = exports.SOURCEMAP_RE = void 0;
+exports.matchSourceMappingURL = matchSourceMappingURL;
+exports.loadSourceMapUrl = loadSourceMapUrl;
+exports.loadSourceMap = loadSourceMap;
+exports.remapSourceLocation = remapSourceLocation;
+const feature_flags_1 = require("@atlaspack/feature-flags");
+const source_map_1 = __importDefault(require("@parcel/source-map"));
+const path_1 = __importDefault(require("path"));
+const path_2 = require("./path");
+exports.SOURCEMAP_RE = /(?:\/\*|\/\/)\s*[@#]\s*sourceMappingURL\s*=\s*([^\s*]+)(?:\s*\*\/)?\s*$/;
+const DATA_URL_RE = /^data:[^;]+(?:;charset=[^;]+)?;base64,(.*)/;
+exports.SOURCEMAP_EXTENSIONS = new Set([
+    'css',
+    'es',
+    'es6',
+    'js',
+    'jsx',
+    'mjs',
+    'ts',
+    'tsx',
+]);
+function matchSourceMappingURL(contents) {
+    return contents.match(exports.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, path_2.isAbsolute)(mapFilePath)
+                ? mapFilePath
+                : path_1.default.join(path_1.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_1.default.dirname(filename);
+        if (foundMap.map.sourceRoot &&
+            !(0, path_2.normalizeSeparators)(foundMap.map.sourceRoot).startsWith('/')) {
+            mapSourceRoot = path_1.default.join(mapSourceRoot, foundMap.map.sourceRoot);
+        }
+        let sourcemapInstance = new source_map_1.default(options.projectRoot);
+        sourcemapInstance.addVLQMap({
+            ...foundMap.map,
+            sources: foundMap.map.sources.map((s) => {
+                return path_1.default.join(mapSourceRoot, s);
+            }),
+        });
+        return sourcemapInstance;
+    }
+}
+function remapSourceLocation(loc, originalMap, projectRoot) {
+    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 - 1);
+    let end = originalMap.findClosestMapping(endLine, endCol - 1);
+    if (start?.original) {
+        if (start.source) {
+            if ((0, feature_flags_1.getFeatureFlag)('symbolLocationFix') &&
+                !path_1.default.isAbsolute(start.source)) {
+                filePath = path_1.default.join(projectRoot, start.source);
+            }
+            else {
+                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++; // source map columns are 0-based
+        if (endLine < startLine) {
+            endLine = startLine;
+            endCol = startCol;
+        }
+        else if (endLine === startLine && endCol < startCol && lineDiff === 0) {
+            endCol = startCol + colDiff;
+        }
+        else if (endLine === startLine && startCol === endCol && lineDiff === 0) {
+            // Prevent 0-length ranges
+            endCol = startCol + 1;
+        }
+    }
+    else {
+        endLine = startLine;
+        endCol = startCol;
+    }
+    return {
+        filePath,
+        start: {
+            line: startLine,
+            column: startCol,
+        },
+        end: {
+            line: endLine,
+            column: endCol,
+        },
+    };
+}

package/dist/stream.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.measureStreamLength = measureStreamLength;
+exports.readableFromStringOrBuffer = readableFromStringOrBuffer;
+exports.bufferStream = bufferStream;
+exports.blobToStream = blobToStream;
+exports.streamFromPromise = streamFromPromise;
+exports.fallbackStream = fallbackStream;
+const stream_1 = require("stream");
+function measureStreamLength(stream) {
+    return new Promise((resolve, reject) => {
+        let length = 0;
+        stream.on('data', (chunk) => {
+            length += chunk;
+        });
+        stream.on('end', () => resolve(length));
+        stream.on('error', reject);
+    });
+}
+function readableFromStringOrBuffer(str) {
+    // https://stackoverflow.com/questions/12755997/how-to-create-streams-from-string-in-node-js
+    const stream = new stream_1.Readable();
+    stream.push(str);
+    stream.push(null);
+    return stream;
+}
+function bufferStream(stream) {
+    return new Promise((resolve, reject) => {
+        let buf = Buffer.from([]);
+        stream.on('data', (data) => {
+            buf = Buffer.concat([buf, data]);
+        });
+        stream.on('end', () => {
+            resolve(buf);
+        });
+        stream.on('error', reject);
+    });
+}
+function blobToStream(blob) {
+    if (blob instanceof stream_1.Readable) {
+        return blob;
+    }
+    return readableFromStringOrBuffer(blob);
+}
+function streamFromPromise(promise) {
+    const stream = new stream_1.PassThrough();
+    promise.then((blob) => {
+        if (blob instanceof stream_1.Readable) {
+            blob.pipe(stream);
+        }
+        else {
+            stream.end(blob);
+        }
+    });
+    return stream;
+}
+function fallbackStream(stream, fallback) {
+    const res = new stream_1.PassThrough();
+    stream.on('error', (err) => {
+        if (err.code === 'ENOENT') {
+            fallback().pipe(res);
+        }
+        else {
+            res.emit('error', err);
+        }
+    });
+    stream.pipe(res);
+    return res;
+}

package/dist/throttle.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = throttle;
+function throttle(fn, delay) {
+    let lastCalled;
+    return function throttled(...args) {
+        if (lastCalled == null || lastCalled + delay <= Date.now()) {
+            fn.call(this, ...args);
+            lastCalled = Date.now();
+        }
+    };
+}

package/dist/urlJoin.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = urlJoin;
+const url_1 = __importDefault(require("url"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Joins a path onto a URL, and normalizes Windows paths
+ * e.g. from \path\to\res.js to /path/to/res.js.
+ */
+function urlJoin(publicURL, assetPath) {
+    const url = url_1.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_1.default.parse(p);
+    url.pathname = path_1.default.posix.join(url.pathname ?? '', assetUrl.pathname ?? '');
+    url.search = assetUrl.search;
+    url.hash = assetUrl.hash;
+    return url_1.default.format(url);
+}

package/lib/DefaultMap.js

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

package/lib/Deferred.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.makeDeferredWithPromise = makeDeferredWithPromise;
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+  _assert = function () {
+    return data;
+  };
+  return data;
+}
+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

@@ -0,0 +1,112 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _Deferred = require("./Deferred");
+class PromiseQueue {
+  _numRunning = 0;
+  _queue = [];
+  _runPromise = null;
+  _count = 0;
+  _results = [];
+  _addSubscriptions = new Set();
+  constructor(opts = {
+    maxConcurrent: Infinity
+  }) {
+    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) {
+    new Promise((resolve, reject) => {
+      let i = this._count++;
+      let wrapped = () => fn().then(result => {
+        this._results[i] = result;
+        resolve(result);
+      }, err => {
+        reject(err);
+        throw err;
+      });
+      this._queue.push(wrapped);
+      for (const addFn of this._addSubscriptions) {
+        addFn();
+      }
+      if (this._numRunning > 0 && this._numRunning < this._maxConcurrent) {
+        this._next();
+      }
+    }).catch(() => {});
+  }
+  subscribeToAdd(fn) {
+    this._addSubscriptions.add(fn);
+    return () => {
+      this._addSubscriptions.delete(fn);
+    };
+  }
+  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._done();
+    }
+  }
+  async _runFn(fn) {
+    this._numRunning++;
+    try {
+      await fn();
+    } catch (e) {
+      // 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--;
+    }
+  }
+  _resetState() {
+    this._queue = [];
+    this._count = 0;
+    this._results = [];
+    this._runPromise = null;
+    this._numRunning = 0;
+    this._deferred = null;
+  }
+  _done() {
+    if (this._deferred != null) {
+      if (this._error != null) {
+        this._deferred.reject(this._error);
+      } else {
+        this._deferred.resolve(this._results);
+      }
+    }
+    this._resetState();
+  }
+}
+exports.default = PromiseQueue;

package/lib/TapStream.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _stream() {
+  const data = require("stream");
+  _stream = function () {
+    return data;
+  };
+  return data;
+}
+/*
+ * "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({
+      ...options
+    });
+    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/alternatives.js

@@ -0,0 +1,116 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findAlternativeFiles = findAlternativeFiles;
+exports.findAlternativeNodeModules = findAlternativeNodeModules;
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+var _schema = require("./schema");
+var _path2 = require("./path");
+var _config = require("./config");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+async function findAlternativeNodeModules(fs, moduleName, dir) {
+  let potentialModules = [];
+  let root = _path().default.parse(dir).root;
+  let isOrganisationModule = moduleName.startsWith('@');
+  while (dir !== root) {
+    // Skip node_modules directories
+    if (_path().default.basename(dir) === 'node_modules') {
+      dir = _path().default.dirname(dir);
+    }
+    try {
+      let modulesDir = _path().default.join(dir, 'node_modules');
+      let stats = await fs.stat(modulesDir);
+      if (stats.isDirectory()) {
+        let dirContent = (await fs.readdir(modulesDir)).sort();
+
+        // Filter out the modules that interest us
+        let modules = dirContent.filter(i => isOrganisationModule ? i.startsWith('@') : !i.startsWith('@'));
+
+        // If it's an organisation module, loop through all the modules of that organisation
+        if (isOrganisationModule) {
+          await Promise.all(modules.map(async item => {
+            let orgDirPath = _path().default.join(modulesDir, item);
+            let orgDirContent = (await fs.readdir(orgDirPath)).sort();
+
+            // Add all org packages
+            potentialModules.push(...orgDirContent.map(i => `${item}/${i}`));
+          }));
+        } else {
+          potentialModules.push(...modules);
+        }
+      }
+    } catch (err) {
+      // ignore
+    }
+
+    // Move up a directory
+    dir = _path().default.dirname(dir);
+  }
+  return (0, _schema.fuzzySearch)(potentialModules.sort(), moduleName).slice(0, 2);
+}
+async function findAllFilesUp({
+  fs,
+  dir,
+  root,
+  basedir,
+  maxlength,
+  collected,
+  leadingDotSlash = true,
+  includeDirectories = true
+}) {
+  let dirContent = (await fs.readdir(dir)).sort();
+  return Promise.all(dirContent.map(async item => {
+    let fullPath = _path().default.join(dir, item);
+    let relativeFilePath = (0, _path2.relativePath)(basedir, fullPath, leadingDotSlash);
+    if (relativeFilePath.length < maxlength) {
+      let stats = await fs.stat(fullPath);
+      let isDir = stats.isDirectory();
+      if (isDir && includeDirectories || stats.isFile()) {
+        collected.push(relativeFilePath);
+      }
+
+      // If it's a directory, run over each item within said directory...
+      if (isDir) {
+        return findAllFilesUp({
+          fs,
+          dir: fullPath,
+          root,
+          basedir,
+          maxlength,
+          collected
+        });
+      }
+    }
+  }));
+}
+async function findAlternativeFiles(fs, fileSpecifier, dir, projectRoot, leadingDotSlash = true, includeDirectories = true, includeExtension = false) {
+  let potentialFiles = [];
+  // Find our root, we won't recommend files above the package root as that's bad practise
+  let pkg = await (0, _config.resolveConfig)(fs, _path().default.join(dir, 'index'), ['package.json'], projectRoot);
+  let pkgRoot = pkg ? _path().default.dirname(pkg) : projectRoot;
+  await findAllFilesUp({
+    fs,
+    dir: pkgRoot,
+    root: pkgRoot,
+    basedir: dir,
+    maxlength: fileSpecifier.length + 10,
+    collected: potentialFiles,
+    leadingDotSlash,
+    includeDirectories
+  });
+  if (_path().default.extname(fileSpecifier) === '' && !includeExtension) {
+    potentialFiles = potentialFiles.map(p => {
+      let ext = _path().default.extname(p);
+      return ext.length > 0 ? p.slice(0, -ext.length) : p;
+    });
+  }
+  return (0, _schema.fuzzySearch)(potentialFiles.sort(), fileSpecifier).slice(0, 2);
+}

package/lib/ansi-html.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ansiHtml = ansiHtml;
+function _ansiHtmlCommunity() {
+  const data = _interopRequireDefault(require("ansi-html-community"));
+  _ansiHtmlCommunity = function () {
+    return data;
+  };
+  return data;
+}
+var _escapeHtml = require("./escape-html");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// @ts-expect-error ansi-html-community is not typed
+
+function ansiHtml(ansi) {
+  return (0, _ansiHtmlCommunity().default)((0, _escapeHtml.escapeHTML)(ansi));
+}

package/lib/blob.js

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

package/lib/bundle-url.js

@@ -0,0 +1,34 @@
+"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 = exports.getBundleURL = getBundleURLCached;