@atlaspack/utils 2.14.5-canary.49 → 2.14.5-canary.490

package/src/{DefaultMap.js → DefaultMap.ts}

@@ -1,9 +1,7 @@
-// @flow strict-local
-
 export class DefaultMap<K, V> extends Map<K, V> {
-  _getDefault: (K) => V;
+  _getDefault: (arg1: K) => V;
 
-  constructor(getDefault: (K) => V, entries?: Iterable<[K, V]>) {
+  constructor(getDefault: (arg1: K) => V, entries?: Iterable<[K, V]>) {
     super(entries);
     this._getDefault = getDefault;
   }
@@ -17,8 +15,7 @@ export class DefaultMap<K, V> extends Map<K, V> {
       this.set(key, ret);
     }
 
-    // $FlowFixMe
-    return ret;
+    return ret as V;
   }
 }
 
@@ -26,11 +23,11 @@ interface Key {}
 
 // Duplicated from DefaultMap implementation for Flow
 // Roughly mirrors https://github.com/facebook/flow/blob/2eb5a78d92c167117ba9caae070afd2b9f598599/lib/core.js#L617
-export class DefaultWeakMap<K: Key, V> extends WeakMap<K, V> {
-  _getDefault: (K) => V;
+export class DefaultWeakMap<K extends Key, V> extends WeakMap<K, V> {
+  _getDefault: (arg1: K) => V;
 
-  constructor(getDefault: (K) => V, entries?: Iterable<[K, V]>) {
-    super(entries);
+  constructor(getDefault: (arg1: K) => V, entries?: Iterable<[K, V]>) {
+    super(entries as Iterable<readonly [K, V]>);
     this._getDefault = getDefault;
   }
 
@@ -43,7 +40,6 @@ export class DefaultWeakMap<K: Key, V> extends WeakMap<K, V> {
       this.set(key, ret);
     }
 
-    // $FlowFixMe
-    return ret;
+    return ret as V;
   }
 }

package/src/Deferred.ts

@@ -0,0 +1,26 @@
+import invariant from 'assert';
+
+export type Deferred<T> = {
+  resolve(arg1: T): void;
+  reject(arg1: unknown): void;
+};
+
+export function makeDeferredWithPromise<T>(): {
+  deferred: Deferred<T>;
+  promise: Promise<T>;
+} {
+  let deferred: Deferred<T> | null | undefined;
+  let promise = new Promise<T>(
+    (
+      resolve: (result: Promise<T> | T) => void,
+      reject: (error?: any) => void,
+    ) => {
+      deferred = {resolve, reject};
+    },
+  );
+
+  // Promise constructor callback executes synchronously, so this is defined
+  invariant(deferred != null);
+
+  return {deferred, promise};
+}

package/src/{PromiseQueue.js → PromiseQueue.ts}

@@ -1,16 +1,16 @@
-// @flow strict-local
-
 import {makeDeferredWithPromise, type Deferred} from './Deferred';
 
-type PromiseQueueOpts = {|maxConcurrent: number|};
+type PromiseQueueOpts = {
+  maxConcurrent: number;
+};
 
 export default class PromiseQueue<T> {
-  _deferred: ?Deferred<Array<T>>;
+  _deferred: Deferred<Array<T>> | null | undefined;
   _maxConcurrent: number;
   _numRunning: number = 0;
   _queue: Array<() => Promise<void>> = [];
-  _runPromise: ?Promise<Array<T>> = null;
-  _error: mixed;
+  _runPromise: Promise<Array<T>> | null | undefined = null;
+  _error: unknown;
   _count: number = 0;
   _results: Array<T> = [];
   _addSubscriptions: Set<() => void> = new Set();
@@ -28,30 +28,35 @@ export default class PromiseQueue<T> {
   }
 
   add(fn: () => Promise<T>): void {
-    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(() => {});
+    new Promise(
+      (
+        resolve: (result: Promise<T> | T) => void,
+        reject: (error?: any) => void,
+      ) => {
+        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: () => void): () => void {
@@ -71,9 +76,9 @@ export default class PromiseQueue<T> {
       return Promise.resolve([]);
     }
 
-    let {deferred, promise} = makeDeferredWithPromise();
+    let {deferred, promise} = makeDeferredWithPromise<Array<T>>();
     this._deferred = deferred;
-    this._runPromise = promise;
+    this._runPromise = promise as Promise<Array<T>>;
 
     while (this._queue.length && this._numRunning < this._maxConcurrent) {
       this._next();
@@ -84,7 +89,7 @@ export default class PromiseQueue<T> {
 
   async _next(): Promise<void> {
     let fn = this._queue.shift();
-    await this._runFn(fn);
+    await this._runFn(fn as () => unknown);
     if (this._queue.length) {
       this._next();
     } else if (this._numRunning === 0) {
@@ -92,11 +97,11 @@ export default class PromiseQueue<T> {
     }
   }
 
-  async _runFn(fn: () => mixed): Promise<void> {
+  async _runFn(fn: () => unknown): Promise<void> {
     this._numRunning++;
     try {
       await fn();
-    } catch (e) {
+    } catch (e: any) {
       // Only store the first error that occurs.
       // We don't reject immediately so that any other concurrent
       // requests have time to complete.

package/src/{TapStream.js → TapStream.ts}

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import {Transform} from 'stream';
 
 /*
@@ -7,21 +5,24 @@ import {Transform} from 'stream';
  * callback. Continues to pass data chunks down the stream.
  */
 export default class TapStream extends Transform {
-  _tap: (Buffer) => mixed;
-  constructor(tap: (Buffer) => mixed, options: mixed) {
-    super({...options});
+  _tap: (arg1: Buffer) => unknown;
+  constructor(tap: (arg1: Buffer) => unknown, options: unknown) {
+    super({...(options as any)});
     this._tap = tap;
   }
 
   _transform(
     chunk: Buffer | string,
     encoding: string,
-    callback: (err: ?Error, chunk?: Buffer | string) => mixed,
+    callback: (
+      err?: Error | null | undefined,
+      chunk?: Buffer | string,
+    ) => unknown,
   ) {
     try {
       this._tap(Buffer.from(chunk));
       callback(null, chunk);
-    } catch (err) {
+    } catch (err: any) {
       callback(err);
     }
   }

package/src/{alternatives.js → alternatives.ts}

@@ -1,6 +1,5 @@
-// @flow
 import path from 'path';
-import type {FileSystem} from '@atlaspack/types';
+import type {FileSystem} from '@atlaspack/types-internal';
 import {fuzzySearch} from './schema';
 import {relativePath} from './path';
 import {resolveConfig} from './config';
@@ -48,7 +47,7 @@ export async function findAlternativeNodeModules(
           potentialModules.push(...modules);
         }
       }
-    } catch (err) {
+    } catch (err: any) {
       // ignore
     }
 
@@ -68,16 +67,16 @@ async function findAllFilesUp({
   collected,
   leadingDotSlash = true,
   includeDirectories = true,
-}: {|
-  fs: FileSystem,
-  dir: string,
-  root: string,
-  basedir: string,
-  maxlength: number,
-  collected: Array<string>,
-  leadingDotSlash?: boolean,
-  includeDirectories?: boolean,
-|}): Promise<mixed> {
+}: {
+  fs: FileSystem;
+  dir: string;
+  root: string;
+  basedir: string;
+  maxlength: number;
+  collected: Array<string>;
+  leadingDotSlash?: boolean;
+  includeDirectories?: boolean;
+}): Promise<unknown> {
   let dirContent = (await fs.readdir(dir)).sort();
   return Promise.all(
     dirContent.map(async (item) => {
@@ -111,9 +110,9 @@ export async function findAlternativeFiles(
   fileSpecifier: string,
   dir: string,
   projectRoot: string,
-  leadingDotSlash?: boolean = true,
-  includeDirectories?: boolean = true,
-  includeExtension?: boolean = false,
+  leadingDotSlash: boolean = true,
+  includeDirectories: boolean = true,
+  includeExtension: boolean = false,
 ): Promise<Array<string>> {
   let potentialFiles: Array<string> = [];
   // Find our root, we won't recommend files above the package root as that's bad practise

package/src/{ansi-html.js → ansi-html.ts}

@@ -1,4 +1,4 @@
-// @flow strict-local
+// @ts-expect-error ansi-html-community is not typed
 import ansiHTML from 'ansi-html-community';
 import {escapeHTML} from './escape-html';
 

package/src/{blob.js → blob.ts}

@@ -1,6 +1,4 @@
-// @flow strict-local
-
-import type {Blob} from '@atlaspack/types';
+import type {Blob} from '@atlaspack/types-internal';
 
 import {Buffer} from 'buffer';
 import {bufferStream} from './';
@@ -12,7 +10,7 @@ export function blobToBuffer(blob: Blob): Promise<Buffer> {
   } else if (blob instanceof Buffer) {
     return Promise.resolve(Buffer.from(blob));
   } else {
-    return Promise.resolve(Buffer.from(blob, 'utf8'));
+    return Promise.resolve(Buffer.from(blob as string, 'utf8'));
   }
 }
 
@@ -22,6 +20,6 @@ export async function blobToString(blob: Blob): Promise<string> {
   } else if (blob instanceof Buffer) {
     return blob.toString();
   } else {
-    return blob;
+    return blob as string;
   }
 }

package/src/{bundle-url.js → bundle-url.ts}

@@ -1,6 +1,4 @@
-// @flow strict-local
-
-let bundleURL: ?string = null;
+let bundleURL: string | null | undefined = null;
 function getBundleURLCached(): string {
   if (bundleURL == null) {
     bundleURL = _getBundleURL();
@@ -13,7 +11,7 @@ function _getBundleURL(): string {
   // Attempt to find the URL of the current script and use that as the base URL
   try {
     throw new Error();
-  } catch (err) {
+  } catch (err: any) {
     let stack: string = typeof err.stack === 'string' ? err.stack : '';
     let matches = stack.match(/(https?|file|ftp):\/\/[^)\n]+/g);
     if (matches) {
@@ -24,7 +22,7 @@ function _getBundleURL(): string {
   return '/';
 }
 
-export function getBaseURL(url: ?string): string {
+export function getBaseURL(url?: string | null): string {
   if (url == null) {
     return '/';
   }

package/src/{collection.js → collection.ts}

@@ -1,20 +1,16 @@
-// @flow strict-local
-
 export function unique<T>(array: Array<T>): Array<T> {
   return [...new Set(array)];
 }
 
 export function objectSortedEntries(obj: {
-  +[string]: mixed,
-  ...
-}): Array<[string, mixed]> {
+  readonly [key: string]: unknown;
+}): Array<[string, unknown]> {
   return Object.entries(obj).sort(([keyA], [keyB]) => keyA.localeCompare(keyB));
 }
 
 export function objectSortedEntriesDeep(object: {
-  +[string]: mixed,
-  ...
-}): Array<[string, mixed]> {
+  readonly [key: string]: unknown;
+}): Array<[string, unknown]> {
   let sortedEntries = objectSortedEntries(object);
   for (let i = 0; i < sortedEntries.length; i++) {
     sortedEntries[i][1] = sortEntry(sortedEntries[i][1]);
@@ -22,13 +18,13 @@ export function objectSortedEntriesDeep(object: {
   return sortedEntries;
 }
 
-function sortEntry(entry: mixed) {
+function sortEntry(entry: unknown): unknown {
   if (Array.isArray(entry)) {
     return entry.map(sortEntry);
   }
 
   if (typeof entry === 'object' && entry != null) {
-    return objectSortedEntriesDeep(entry);
+    return objectSortedEntriesDeep(entry as {readonly [key: string]: unknown});
   }
 
   return entry;
@@ -44,11 +40,8 @@ function sortEntry(entry: mixed) {
  * @param {*} b Set B
  * @returns A \ B
  */
-export function setDifference<T>(
-  a: $ReadOnlySet<T>,
-  b: $ReadOnlySet<T>,
-): Set<T> {
-  let difference = new Set();
+export function setDifference<T>(a: ReadonlySet<T>, b: ReadonlySet<T>): Set<T> {
+  let difference = new Set<T>();
   for (let e of a) {
     if (!b.has(e)) {
       difference.add(e);
@@ -69,10 +62,10 @@ export function setDifference<T>(
  * @returns A Δ B
  */
 export function setSymmetricDifference<T>(
-  a: $ReadOnlySet<T>,
-  b: $ReadOnlySet<T>,
+  a: ReadonlySet<T>,
+  b: ReadonlySet<T>,
 ): Set<T> {
-  let difference = new Set();
+  let difference = new Set<T>();
   for (let e of a) {
     if (!b.has(e)) {
       difference.add(e);
@@ -86,7 +79,7 @@ export function setSymmetricDifference<T>(
   return difference;
 }
 
-export function setIntersect<T>(a: Set<T>, b: $ReadOnlySet<T>): void {
+export function setIntersect<T>(a: Set<T>, b: ReadonlySet<T>): void {
   for (let entry of a) {
     if (!b.has(entry)) {
       a.delete(entry);
@@ -94,11 +87,21 @@ export function setIntersect<T>(a: Set<T>, b: $ReadOnlySet<T>): void {
   }
 }
 
+export function setIntersectStatic<T>(a: Set<T>, b: Set<T>): Set<T> {
+  let intersection = new Set<T>();
+  for (let entry of a) {
+    if (b.has(entry)) {
+      intersection.add(entry);
+    }
+  }
+  return intersection;
+}
+
 export function setUnion<T>(a: Iterable<T>, b: Iterable<T>): Set<T> {
   return new Set([...a, ...b]);
 }
 
-export function setEqual<T>(a: $ReadOnlySet<T>, b: $ReadOnlySet<T>): boolean {
+export function setEqual<T>(a: ReadonlySet<T>, b: ReadonlySet<T>): boolean {
   if (a.size != b.size) {
     return false;
   }

package/src/{config.js → config.ts}

@@ -1,23 +1,22 @@
-// @flow
-
-import type {ConfigResult, File, FilePath} from '@atlaspack/types';
-import type {FileSystem} from '@atlaspack/fs';
+import type {ConfigResult, File, FilePath} from '@atlaspack/types-internal';
+import type {FileSystem} from '@atlaspack/types-internal';
 import ThrowableDiagnostic from '@atlaspack/diagnostic';
 import path from 'path';
+// @ts-expect-error TS7016
 import clone from 'clone';
 import json5 from 'json5';
 import {parse as toml} from '@iarna/toml';
-import LRU from 'lru-cache';
+import {LRUCache as LRU} from 'lru-cache';
 
-export type ConfigOutput = {|
-  config: ConfigResult,
-  files: Array<File>,
-|};
+export type ConfigOutput = {
+  config: ConfigResult;
+  files: Array<File>;
+};
 
-export type ConfigOptions = {|
-  parse?: boolean,
-  parser?: (string) => any,
-|};
+export type ConfigOptions = {
+  parse?: boolean;
+  parser?: (arg1: string) => any;
+};
 
 const configCache = new LRU<FilePath, ConfigOutput>({max: 500});
 const resolveCache = new Map();
@@ -27,7 +26,7 @@ export function resolveConfig(
   filepath: FilePath,
   filenames: Array<FilePath>,
   projectRoot: FilePath,
-): Promise<?FilePath> {
+): Promise<FilePath | null | undefined> {
   // Cache the result of resolving config for this directory.
   // This is automatically invalidated at the end of the current build.
   let key = path.dirname(filepath) + filenames.join(',');
@@ -50,7 +49,7 @@ export function resolveConfigSync(
   filepath: FilePath,
   filenames: Array<FilePath>,
   projectRoot: FilePath,
-): ?FilePath {
+): FilePath | null | undefined {
   return fs.findAncestorFile(filenames, path.dirname(filepath), projectRoot);
 }
 
@@ -59,7 +58,7 @@ export async function loadConfig(
   filepath: FilePath,
   filenames: Array<FilePath>,
   projectRoot: FilePath,
-  opts: ?ConfigOptions,
+  opts?: ConfigOptions | null,
 ): Promise<ConfigOutput | null> {
   let parse = opts?.parse ?? true;
   let configFile = await resolveConfig(fs, filepath, filenames, projectRoot);
@@ -73,7 +72,6 @@ export async function loadConfig(
       let extname = path.extname(configFile).slice(1);
       if (extname === 'js' || extname === 'cjs') {
         let output = {
-          // $FlowFixMe
           config: clone(module.require(configFile)),
           files: [{filePath: configFile}],
         };
@@ -83,7 +81,7 @@ export async function loadConfig(
       }
 
       return readConfig(fs, configFile, opts);
-    } catch (err) {
+    } catch (err: any) {
       if (err.code === 'MODULE_NOT_FOUND' || err.code === 'ENOENT') {
         return null;
       }
@@ -96,14 +94,14 @@ export async function loadConfig(
 }
 
 loadConfig.clear = () => {
-  configCache.reset();
+  configCache.clear();
   resolveCache.clear();
 };
 
 export async function readConfig(
   fs: FileSystem,
   configFile: FilePath,
-  opts: ?ConfigOptions,
+  opts?: ConfigOptions | null,
 ): Promise<ConfigOutput | null> {
   let parse = opts?.parse ?? true;
   let cachedOutput = configCache.get(String(parse) + configFile);
@@ -121,7 +119,7 @@ export async function readConfig(
       let parse = opts?.parser ?? getParser(extname);
       try {
         config = parse(configContent);
-      } catch (e) {
+      } catch (e: any) {
         if (extname !== '' && extname !== 'json') {
           throw e;
         }
@@ -161,7 +159,7 @@ export async function readConfig(
 
     configCache.set(String(parse) + configFile, output);
     return output;
-  } catch (err) {
+  } catch (err: any) {
     if (err.code === 'MODULE_NOT_FOUND' || err.code === 'ENOENT') {
       return null;
     }
@@ -170,7 +168,7 @@ export async function readConfig(
   }
 }
 
-function getParser(extname) {
+function getParser(extname: string) {
   switch (extname) {
     case 'toml':
       return toml;

package/src/{countLines.js → countLines.ts}

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 export default function countLines(
   string: string,
   startIndex: number = 0,

package/src/{debounce.js → debounce.ts}

@@ -1,10 +1,8 @@
-// @flow strict-local
-
-export default function debounce<TArgs: Array<mixed>>(
-  fn: (...args: TArgs) => mixed,
+export default function debounce<TArgs extends Array<unknown>>(
+  fn: (...args: TArgs) => unknown,
   delay: number,
 ): (...args: TArgs) => void {
-  let timeout;
+  let timeout: NodeJS.Timeout | undefined | null;
 
   return function (...args: TArgs) {
     if (timeout) {

package/src/debug-tools.ts

@@ -0,0 +1,50 @@
+/*
+ * These tools are intended for Atlaspack developers, to provide extra utilities
+ * to make debugging Atlaspack issues more straightforward.
+ *
+ * To enable a tool, set the `ATLASPACK_DEBUG_TOOLS` environment variable to a
+ * comma-separated list of tool names. For example:
+ * `ATLASPACK_DEBUG_TOOLS="asset-file-names-in-output,simple-cli-reporter"`
+ *
+ * You can enable all tools by setting `ATLASPACK_DEBUG_TOOLS=all`.
+ */
+
+type DebugTools = {
+  ['asset-file-names-in-output']: boolean;
+  ['simple-cli-reporter']: boolean;
+  ['bundle-stats']: boolean;
+  ['scope-hoisting-stats']: boolean;
+  ['debug-prelude']: boolean; // Native packager only, here to avoid warnings
+};
+
+export let debugTools: DebugTools = {
+  'asset-file-names-in-output': false,
+  'simple-cli-reporter': false,
+  'bundle-stats': false,
+  'scope-hoisting-stats': false,
+  'debug-prelude': false,
+};
+
+const envVarValue = process.env.ATLASPACK_DEBUG_TOOLS ?? '';
+
+for (let tool of envVarValue.split(',')) {
+  tool = tool.trim();
+
+  if (tool === 'all') {
+    for (let key in debugTools) {
+      debugTools[key as keyof DebugTools] = true;
+    }
+    break;
+  } else if (debugTools.hasOwnProperty(tool)) {
+    debugTools[tool as keyof DebugTools] = true;
+  } else if (tool === '') {
+    continue;
+  } else {
+    // eslint-disable-next-line no-console
+    console.warn(
+      `Unknown debug tool option: ${tool}. Valid options are: ${Object.keys(
+        debugTools,
+      ).join(', ')}`,
+    );
+  }
+}

package/src/{dependency-location.js → dependency-location.ts}

@@ -1,20 +1,24 @@
-// @flow
-
 export default function createDependencyLocation(
-  start: {|
-    line: number,
-    column: number,
-  |},
+  start: {
+    line: number;
+    column: number;
+  },
   specifier: string,
   lineOffset: number = 0,
   columnOffset: number = 0,
   // Imports are usually wrapped in quotes
   importWrapperLength: number = 2,
-): {|
-  end: {|column: number, line: number|},
-  filePath: string,
-  start: {|column: number, line: number|},
-|} {
+): {
+  end: {
+    column: number;
+    line: number;
+  };
+  filePath: string;
+  start: {
+    column: number;
+    line: number;
+  };
+} {
   return {
     filePath: specifier,
     start: {