@atlaspack/utils 2.17.3-typescript-b27501580.0 → 2.17.3-typescript-5b4d3ad41.0

package/lib/DefaultMap.d.ts

@@ -0,0 +1,13 @@
+export declare class DefaultMap<K, V> extends Map<K, V> {
+    _getDefault: (arg1: K) => V;
+    constructor(getDefault: (arg1: K) => V, entries?: Iterable<[K, V]>);
+    get(key: K): V;
+}
+interface Key {
+}
+export declare class DefaultWeakMap<K extends Key, V> extends WeakMap<K, V> {
+    _getDefault: (arg1: K) => V;
+    constructor(getDefault: (arg1: K) => V, entries?: Iterable<[K, V]>);
+    get(key: K): V;
+}
+export {};

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.d.ts

@@ -0,0 +1,8 @@
+export type Deferred<T> = {
+    resolve(arg1: T): void;
+    reject(arg1: unknown): void;
+};
+export declare function makeDeferredWithPromise<T>(): {
+    deferred: Deferred<T>;
+    promise: Promise<T>;
+};

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.d.ts

@@ -0,0 +1,25 @@
+import { type Deferred } from './Deferred';
+type PromiseQueueOpts = {
+    maxConcurrent: number;
+};
+export default class PromiseQueue<T> {
+    _deferred: Deferred<Array<T>> | null | undefined;
+    _maxConcurrent: number;
+    _numRunning: number;
+    _queue: Array<() => Promise<void>>;
+    _runPromise: Promise<Array<T>> | null | undefined;
+    _error: unknown;
+    _count: number;
+    _results: Array<T>;
+    _addSubscriptions: Set<() => void>;
+    constructor(opts?: PromiseQueueOpts);
+    getNumWaiting(): number;
+    add(fn: () => Promise<T>): void;
+    subscribeToAdd(fn: () => void): () => void;
+    run(): Promise<Array<T>>;
+    _next(): Promise<void>;
+    _runFn(fn: () => unknown): Promise<void>;
+    _resetState(): void;
+    _done(): void;
+}
+export {};

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.d.ts

@@ -0,0 +1,6 @@
+import { Transform } from 'stream';
+export default class TapStream extends Transform {
+    _tap: (arg1: Buffer) => unknown;
+    constructor(tap: (arg1: Buffer) => unknown, options: unknown);
+    _transform(chunk: Buffer | string, encoding: string, callback: (err?: Error | null | undefined, chunk?: Buffer | string) => unknown): void;
+}

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.d.ts

@@ -0,0 +1,3 @@
+import type { FileSystem } from '@atlaspack/types';
+export declare function findAlternativeNodeModules(fs: FileSystem, moduleName: string, dir: string): Promise<Array<string>>;
+export declare function findAlternativeFiles(fs: FileSystem, fileSpecifier: string, dir: string, projectRoot: string, leadingDotSlash?: boolean, includeDirectories?: boolean, includeExtension?: boolean): Promise<Array<string>>;

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.d.ts

@@ -0,0 +1 @@
+export declare function ansiHtml(ansi: string): string;

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.d.ts

@@ -0,0 +1,4 @@
+import type { Blob } from '@atlaspack/types';
+import { Buffer } from 'buffer';
+export declare function blobToBuffer(blob: Blob): Promise<Buffer>;
+export declare function blobToString(blob: Blob): Promise<string>;

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.d.ts

@@ -0,0 +1,4 @@
+declare function getBundleURLCached(): string;
+export declare function getBaseURL(url?: string | null): string;
+export declare const getBundleURL: typeof getBundleURLCached;
+export {};

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.d.ts

@@ -0,0 +1,33 @@
+export declare function unique<T>(array: Array<T>): Array<T>;
+export declare function objectSortedEntries(obj: {
+    readonly [key: string]: unknown;
+}): Array<[string, unknown]>;
+export declare function objectSortedEntriesDeep(object: {
+    readonly [key: string]: unknown;
+}): Array<[string, unknown]>;
+/**
+ * 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
+ */
+export declare function setDifference<T>(a: ReadonlySet<T>, b: ReadonlySet<T>): Set<T>;
+/**
+ * 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
+ */
+export declare function setSymmetricDifference<T>(a: ReadonlySet<T>, b: ReadonlySet<T>): Set<T>;
+export declare function setIntersect<T>(a: Set<T>, b: ReadonlySet<T>): void;
+export declare function setIntersectStatic<T>(a: Set<T>, b: Set<T>): Set<T>;
+export declare function setUnion<T>(a: Iterable<T>, b: Iterable<T>): Set<T>;
+export declare function setEqual<T>(a: ReadonlySet<T>, b: ReadonlySet<T>): boolean;

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;
+}

package/lib/config.d.ts

@@ -0,0 +1,17 @@
+import type { ConfigResult, File, FilePath } from '@atlaspack/types';
+import type { FileSystem } from '@atlaspack/fs';
+export type ConfigOutput = {
+    config: ConfigResult;
+    files: Array<File>;
+};
+export type ConfigOptions = {
+    parse?: boolean;
+    parser?: (arg1: string) => any;
+};
+export declare function resolveConfig(fs: FileSystem, filepath: FilePath, filenames: Array<FilePath>, projectRoot: FilePath): Promise<FilePath | null | undefined>;
+export declare function resolveConfigSync(fs: FileSystem, filepath: FilePath, filenames: Array<FilePath>, projectRoot: FilePath): FilePath | null | undefined;
+export declare function loadConfig(fs: FileSystem, filepath: FilePath, filenames: Array<FilePath>, projectRoot: FilePath, opts?: ConfigOptions | null): Promise<ConfigOutput | null>;
+export declare namespace loadConfig {
+    var clear: () => void;
+}
+export declare function readConfig(fs: FileSystem, configFile: FilePath, opts?: ConfigOptions | null): Promise<ConfigOutput | null>;