@atlaspack/utils 2.17.2 → 2.17.3-typescript-08dcc1c9b.0

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);
@@ -95,7 +88,7 @@ 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();
+  let intersection = new Set<T>();
   for (let entry of a) {
     if (b.has(entry)) {
       intersection.add(entry);
@@ -108,7 +101,7 @@ 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.js → debug-tools.ts}

@@ -1,5 +1,3 @@
-// @flow
-
 /*
  * These tools are intended for Atlaspack developers, to provide extra utilities
  * to make debugging Atlaspack issues more straightforward.
@@ -11,10 +9,10 @@
  * You can enable all tools by setting `ATLASPACK_DEBUG_TOOLS=all`.
  */
 
-type DebugTools = {|
-  'asset-file-names-in-output': boolean,
-  'simple-cli-reporter': boolean,
-|};
+type DebugTools = {
+  ['asset-file-names-in-output']: boolean;
+  ['simple-cli-reporter']: boolean;
+};
 
 export let debugTools: DebugTools = {
   'asset-file-names-in-output': false,
@@ -28,11 +26,11 @@ for (let tool of envVarValue.split(',')) {
 
   if (tool === 'all') {
     for (let key in debugTools) {
-      debugTools[key] = true;
+      debugTools[key as keyof DebugTools] = true;
     }
     break;
   } else if (debugTools.hasOwnProperty(tool)) {
-    debugTools[tool] = true;
+    debugTools[tool as keyof DebugTools] = true;
   } else if (tool === '') {
     continue;
   } else {

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,5 +1,5 @@
-// @flow
 import type {FileSystem} from '@atlaspack/fs';
+// @ts-expect-error TS7016
 import forge from 'node-forge';
 import path from 'path';
 import logger from '@atlaspack/logger';
@@ -7,8 +7,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 +137,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,11 +1,12 @@
-// @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';
-import micromatch, {isMatch, makeRe, type Options} from 'micromatch';
+// @ts-expect-error TS2305
+import fastGlob, {FastGlobOptions} from 'fast-glob';
+// @ts-expect-error TS7016
+import micromatch, {isMatch, makeRe, Options} from 'micromatch';
 import {normalizeSeparators} from './path';
 
 export function isGlob(p: FilePath): any {
@@ -44,25 +45,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 +74,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 +104,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> {