@atlaspack/utils 2.14.5-canary.14 → 2.14.5-canary.141

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,24 +1,24 @@
-// @flow
-
 import type {ConfigResult, File, FilePath} from '@atlaspack/types';
 import type {FileSystem} from '@atlaspack/fs';
 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';
 
-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;
+};
 
+// @ts-expect-error TS2351
 const configCache = new LRU<FilePath, ConfigOutput>({max: 500});
 const resolveCache = new Map();
 
@@ -27,7 +27,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 +50,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 +59,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 +73,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 +82,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;
       }
@@ -103,7 +102,7 @@ loadConfig.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 +120,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 +160,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 +169,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,43 @@
+/*
+ * 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;
+};
+
+export let debugTools: DebugTools = {
+  'asset-file-names-in-output': false,
+  'simple-cli-reporter': 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 {
+    throw new Error(
+      `Invalid 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: {

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

@@ -1,4 +1,3 @@
-// @flow
 // Based on _.escape https://github.com/lodash/lodash/blob/master/escape.js
 const reUnescapedHtml = /[&<>"']/g;
 const reHasUnescapedHtml = RegExp(reUnescapedHtml.source);
@@ -9,11 +8,14 @@ const htmlEscapes = {
   '>': '&gt;',
   '"': '&quot;',
   "'": '&#39;',
-};
+} as const;
 
 export function escapeHTML(s: string): string {
   if (reHasUnescapedHtml.test(s)) {
-    return s.replace(reUnescapedHtml, (c) => htmlEscapes[c]);
+    return s.replace(
+      reUnescapedHtml,
+      (c) => htmlEscapes[c as keyof typeof htmlEscapes],
+    );
   }
 
   return s;

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

@@ -1,5 +1,3 @@
-// @flow
-
 import type {FilePath, PackagedBundle} from '@atlaspack/types';
 import type {FileSystem} from '@atlaspack/fs';
 import SourceMap from '@parcel/source-map';
@@ -7,29 +5,29 @@ import nullthrows from 'nullthrows';
 import path from 'path';
 import {loadSourceMapUrl} from './';
 
-export type AssetStats = {|
-  filePath: string,
-  size: number,
-  originalSize: number,
-  time: number,
-|};
+export type AssetStats = {
+  filePath: string;
+  size: number;
+  originalSize: number;
+  time: number;
+};
 
-export type BundleStats = {|
-  filePath: string,
-  size: number,
-  time: number,
-  assets: Array<AssetStats>,
-|};
+export type BundleStats = {
+  filePath: string;
+  size: number;
+  time: number;
+  assets: Array<AssetStats>;
+};
 
-export type BuildMetrics = {|
-  bundles: Array<BundleStats>,
-|};
+export type BuildMetrics = {
+  bundles: Array<BundleStats>;
+};
 
 async function getSourcemapSizes(
   filePath: FilePath,
   fs: FileSystem,
   projectRoot: FilePath,
-): Promise<?Map<string, number>> {
+): Promise<Map<string, number> | null | undefined> {
   let bundleContents = await fs.readFile(filePath, 'utf-8');
   let mapUrlData = await loadSourceMapUrl(fs, filePath, bundleContents);
   if (!mapUrlData) {

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

@@ -1,4 +1,3 @@
-// @flow
 import type {FileSystem} from '@atlaspack/fs';
 import forge from 'node-forge';
 import path from 'path';
@@ -7,8 +6,11 @@ import logger from '@atlaspack/logger';
 export default async function generateCertificate(
   fs: FileSystem,
   cacheDir: string,
-  host: ?string,
-): Promise<{|cert: Buffer, key: Buffer|}> {
+  host?: string | null,
+): Promise<{
+  cert: Buffer;
+  key: Buffer;
+}> {
   let certDirectory = cacheDir;
 
   const privateKeyPath = path.join(certDirectory, 'private.pem');
@@ -134,7 +136,7 @@ export default async function generateCertificate(
   await fs.writeFile(certPath, certPem);
 
   return {
-    key: privPem,
-    cert: certPem,
+    key: privPem as unknown as Buffer,
+    cert: certPem as unknown as Buffer,
   };
 }

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

@@ -1,17 +1,19 @@
-// @flow
 import type {HTTPSOptions} from '@atlaspack/types';
 import type {FileSystem} from '@atlaspack/fs';
 
 export default async function getCertificate(
   fs: FileSystem,
   options: HTTPSOptions,
-): Promise<{|cert: Buffer, key: Buffer|}> {
+): Promise<{
+  cert: Buffer;
+  key: Buffer;
+}> {
   try {
     let cert = await fs.readFile(options.cert);
     let key = await fs.readFile(options.key);
 
     return {key, cert};
-  } catch (err) {
+  } catch (err: any) {
     throw new Error('Certificate and/or key not found');
   }
 }

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

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import fs from 'fs';
 
 /**
@@ -9,7 +7,10 @@ import fs from 'fs';
 export default function getExisting(
   minifiedPath: string,
   sourcePath: string,
-): {|minified: string, source: string|} {
+): {
+  minified: string;
+  source: string;
+} {
   let source = fs.readFileSync(sourcePath, 'utf8').trim();
   return {
     source,

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

@@ -1,4 +1,3 @@
-// @flow strict-local
 import path from 'path';
 
 import {normalizeSeparators} from './path';
@@ -6,7 +5,9 @@ import {normalizeSeparators} from './path';
 /**
  * Returns the package name and the optional subpath
  */
-export default function getModuleParts(_name: string): [string, ?string] {
+export default function getModuleParts(
+  _name: string,
+): [string, string | null | undefined] {
   let name = path.normalize(_name);
   let splitOn = name.indexOf(path.sep);
   if (name.charAt(0) === '@') {

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

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import type {FilePath} from '@atlaspack/types';
 import {isGlob} from './glob';
 import path from 'path';

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

@@ -1,10 +1,10 @@
-// @flow
-
 import type {FilePath, Glob} from '@atlaspack/types';
 import type {FileSystem} from '@atlaspack/fs';
 
+// @ts-expect-error TS7016
 import _isGlob from 'is-glob';
-import fastGlob, {type FastGlobOptions} from 'fast-glob';
+// @ts-expect-error TS2305
+import fastGlob, {FastGlobOptions} from 'fast-glob';
 import micromatch, {isMatch, makeRe, type Options} from 'micromatch';
 import {normalizeSeparators} from './path';
 
@@ -44,25 +44,27 @@ export function globSync(
   fs: FileSystem,
   options?: FastGlobOptions<FilePath>,
 ): Array<FilePath> {
-  // $FlowFixMe
   options = {
     ...options,
     fs: {
+      // @ts-expect-error TS7006
       statSync: (p) => {
         return fs.statSync(p);
       },
+      // @ts-expect-error TS7006
       lstatSync: (p) => {
         // Our FileSystem interface doesn't have lstat support at the moment,
         // but this is fine for our purposes since we follow symlinks by default.
         return fs.statSync(p);
       },
+      // @ts-expect-error TS7006
       readdirSync: (p, opts) => {
         return fs.readdirSync(p, opts);
       },
     },
   };
 
-  // $FlowFixMe
+  // @ts-expect-error TS2322
   return fastGlob.sync(normalizeSeparators(p), options);
 }
 
@@ -71,26 +73,28 @@ export function glob(
   fs: FileSystem,
   options: FastGlobOptions<FilePath>,
 ): Promise<Array<FilePath>> {
-  // $FlowFixMe
   options = {
     ...options,
     fs: {
+      // @ts-expect-error TS7006
       stat: async (p, cb) => {
         try {
           cb(null, await fs.stat(p));
-        } catch (err) {
+        } catch (err: any) {
           cb(err);
         }
       },
+      // @ts-expect-error TS7006
       lstat: async (p, cb) => {
         // Our FileSystem interface doesn't have lstat support at the moment,
         // but this is fine for our purposes since we follow symlinks by default.
         try {
           cb(null, await fs.stat(p));
-        } catch (err) {
+        } catch (err: any) {
           cb(err);
         }
       },
+      // @ts-expect-error TS7006
       readdir: async (p, opts, cb) => {
         if (typeof opts === 'function') {
           cb = opts;
@@ -99,13 +103,13 @@ export function glob(
 
         try {
           cb(null, await fs.readdir(p, opts));
-        } catch (err) {
+        } catch (err: any) {
           cb(err);
         }
       },
     },
   };
 
-  // $FlowFixMe Added in Flow 0.121.0 upgrade in #4381
+  // @ts-expect-error TS2322
   return fastGlob(normalizeSeparators(p), options);
 }

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

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import type {Readable} from 'stream';
 import type {FileSystem} from '@atlaspack/fs';
 
@@ -8,28 +6,35 @@ import {hashString, Hash} from '@atlaspack/rust';
 
 export function hashStream(stream: Readable): Promise<string> {
   let hash = new Hash();
-  return new Promise((resolve, reject) => {
-    stream.on('error', (err) => {
-      reject(err);
-    });
-    stream
-      .on('data', (chunk) => {
-        hash.writeBuffer(chunk);
-      })
-      .on('end', function () {
-        resolve(hash.finish());
-      })
-      .on('error', (err) => {
+  return new Promise(
+    (
+      resolve: (result: Promise<string> | string) => void,
+      reject: (error?: any) => void,
+    ) => {
+      stream.on('error', (err) => {
         reject(err);
       });
-  });
+      stream
+        .on('data', (chunk) => {
+          hash.writeBuffer(chunk);
+        })
+        .on('end', function () {
+          resolve(hash.finish());
+        })
+        .on('error', (err) => {
+          reject(err);
+        });
+    },
+  );
 }
 
-export function hashObject(obj: {+[string]: mixed, ...}): string {
+export function hashObject(obj: {readonly [key: string]: unknown}): string {
   return hashString(JSON.stringify(objectSortedEntriesDeep(obj)));
 }
 
-let testCache: {|[string]: Promise<string>|} = {
+let testCache: {
+  [key: string]: Promise<string>;
+} = {
   /*:: ...null */
 };
 export function hashFile(fs: FileSystem, filePath: string): Promise<string> {