@atlaspack/utils 2.16.2-unified-f92fba5b6.0 → 2.17.0

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # @atlaspack/utils
 
+## 2.17.0
+
+### Minor Changes
+
+- [#640](https://github.com/atlassian-labs/atlaspack/pull/640) [`dbb4072`](https://github.com/atlassian-labs/atlaspack/commit/dbb40721ebeb45990a14ba04e6b44e7f836fb32d) Thanks [@JakeLane](https://github.com/JakeLane)! - Clean up conditional bundling feature flags
+
+- [#693](https://github.com/atlassian-labs/atlaspack/pull/693) [`18a57cf`](https://github.com/atlassian-labs/atlaspack/commit/18a57cf8a4789b2de5ad8e2676f317a26cc91417) Thanks [@mattcompiles](https://github.com/mattcompiles)! - These packages should have been bumped in [pull request 691](https://github.com/atlassian-labs/atlaspack/pull/691).
+
+  Rectifying by creating a new changeset now.
+
+### Patch Changes
+
+- [#645](https://github.com/atlassian-labs/atlaspack/pull/645) [`de23e0c`](https://github.com/atlassian-labs/atlaspack/commit/de23e0ce49d5504fe3947ac26640a3d951087da3) Thanks [@alshdavid](https://github.com/alshdavid)! - Updated build system and added some extra test-specific code
+
+- [#682](https://github.com/atlassian-labs/atlaspack/pull/682) [`a5ed1b4`](https://github.com/atlassian-labs/atlaspack/commit/a5ed1b414498560f393ff491af4da25b6e8dde56) Thanks [@alshdavid](https://github.com/alshdavid)! - Updating build system
+
+- Updated dependencies [[`dbb4072`](https://github.com/atlassian-labs/atlaspack/commit/dbb40721ebeb45990a14ba04e6b44e7f836fb32d), [`becf977`](https://github.com/atlassian-labs/atlaspack/commit/becf977f625d5ee46dae3d4c679f173bf5f40cc0), [`becf977`](https://github.com/atlassian-labs/atlaspack/commit/becf977f625d5ee46dae3d4c679f173bf5f40cc0), [`c4415a4`](https://github.com/atlassian-labs/atlaspack/commit/c4415a455543d984ca28452c2cb87a794d22497c), [`f0f7c71`](https://github.com/atlassian-labs/atlaspack/commit/f0f7c7168a1d3d18c6f30d2daed611275692b7c5), [`de23e0c`](https://github.com/atlassian-labs/atlaspack/commit/de23e0ce49d5504fe3947ac26640a3d951087da3), [`18a57cf`](https://github.com/atlassian-labs/atlaspack/commit/18a57cf8a4789b2de5ad8e2676f317a26cc91417), [`a5ed1b4`](https://github.com/atlassian-labs/atlaspack/commit/a5ed1b414498560f393ff491af4da25b6e8dde56)]:
+  - @atlaspack/feature-flags@2.19.0
+  - @atlaspack/rust@3.4.1
+  - @atlaspack/codeframe@2.13.4
+  - @atlaspack/logger@2.14.13
+
 ## 2.16.1
 
 ### Patch Changes

package/lib/DefaultMap.js

@@ -0,0 +1,46 @@
+"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);
+    }
+
+    // $FlowFixMe
+    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);
+    }
+
+    // $FlowFixMe
+    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,18 @@
+"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 }; }
+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;

package/lib/collection.js

@@ -0,0 +1,111 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.objectSortedEntries = objectSortedEntries;
+exports.objectSortedEntriesDeep = objectSortedEntriesDeep;
+exports.setDifference = setDifference;
+exports.setEqual = setEqual;
+exports.setIntersect = setIntersect;
+exports.setIntersectStatic = setIntersectStatic;
+exports.setSymmetricDifference = setSymmetricDifference;
+exports.setUnion = setUnion;
+exports.unique = unique;
+function unique(array) {
+  return [...new Set(array)];
+}
+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;
+}
+
+/**
+ * Get the difference of A and B sets
+ *
+ * This is the set of elements which are in A but not in B
+ * For example, the difference of the sets {1,2,3} and {3,4} is {1,2}
+ *
+ * @param {*} a Set A
+ * @param {*} b Set B
+ * @returns A \ B
+ */
+function setDifference(a, b) {
+  let difference = new Set();
+  for (let e of a) {
+    if (!b.has(e)) {
+      difference.add(e);
+    }
+  }
+  return difference;
+}
+
+/**
+ * Get the symmetric difference of A and B sets
+ *
+ * This is the set of elements which are in either of the sets, but not in their intersection.
+ * For example, the symmetric difference of the sets {1,2,3} and {3,4} is {1,2,4}
+ *
+ * @param {*} a Set A
+ * @param {*} b Set B
+ * @returns A Δ B
+ */
+function setSymmetricDifference(a, b) {
+  let difference = new Set();
+  for (let e of a) {
+    if (!b.has(e)) {
+      difference.add(e);
+    }
+  }
+  for (let d of b) {
+    if (!a.has(d)) {
+      difference.add(d);
+    }
+  }
+  return difference;
+}
+function setIntersect(a, b) {
+  for (let entry of a) {
+    if (!b.has(entry)) {
+      a.delete(entry);
+    }
+  }
+}
+function setIntersectStatic(a, b) {
+  let intersection = new Set();
+  for (let entry of a) {
+    if (b.has(entry)) {
+      intersection.add(entry);
+    }
+  }
+  return intersection;
+}
+function setUnion(a, b) {
+  return new Set([...a, ...b]);
+}
+function setEqual(a, b) {
+  if (a.size != b.size) {
+    return false;
+  }
+  for (let entry of a) {
+    if (!b.has(entry)) {
+      return false;
+    }
+  }
+  return true;
+}