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

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

@@ -1,3 +1,5 @@
+// @flow
+
 import type {FilePath, PackagedBundle} from '@atlaspack/types';
 import type {FileSystem} from '@atlaspack/fs';
 import SourceMap from '@parcel/source-map';
@@ -5,29 +7,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> | null | undefined> {
+): Promise<?Map<string, number>> {
   let bundleContents = await fs.readFile(filePath, 'utf-8');
   let mapUrlData = await loadSourceMapUrl(fs, filePath, bundleContents);
   if (!mapUrlData) {

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

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

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

@@ -1,19 +1,17 @@
+// @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: any) {
+  } catch (err) {
     throw new Error('Certificate and/or key not found');
   }
 }

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

@@ -1,3 +1,5 @@
+// @flow strict-local
+
 import fs from 'fs';
 
 /**
@@ -7,10 +9,7 @@ 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.ts → getModuleParts.js}

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

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

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

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

@@ -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';
-// @ts-expect-error TS2305
-import fastGlob, {FastGlobOptions} from 'fast-glob';
+import fastGlob, {type FastGlobOptions} from 'fast-glob';
 import micromatch, {isMatch, makeRe, type Options} from 'micromatch';
 import {normalizeSeparators} from './path';
 
@@ -44,27 +44,25 @@ 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);
       },
     },
   };
 
-  // @ts-expect-error TS2322
+  // $FlowFixMe
   return fastGlob.sync(normalizeSeparators(p), options);
 }
 
@@ -73,28 +71,26 @@ 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: any) {
+        } catch (err) {
           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: any) {
+        } catch (err) {
           cb(err);
         }
       },
-      // @ts-expect-error TS7006
       readdir: async (p, opts, cb) => {
         if (typeof opts === 'function') {
           cb = opts;
@@ -103,13 +99,13 @@ export function glob(
 
         try {
           cb(null, await fs.readdir(p, opts));
-        } catch (err: any) {
+        } catch (err) {
           cb(err);
         }
       },
     },
   };
 
-  // @ts-expect-error TS2322
+  // $FlowFixMe Added in Flow 0.121.0 upgrade in #4381
   return fastGlob(normalizeSeparators(p), options);
 }

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

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

package/src/{http-server.ts → http-server.js}

@@ -1,9 +1,15 @@
+// @flow strict-local
+
 import type {
   Server as HTTPOnlyServer,
   IncomingMessage as HTTPRequest,
   ServerResponse as HTTPResponse,
 } from 'http';
-import type {Server as HTTPSServer} from 'https';
+import type {
+  Server as HTTPSServer,
+  IncomingMessage as HTTPSRequest,
+  ServerResponse as HTTPSResponse,
+} from 'https';
 import type {Socket} from 'net';
 import type {FilePath, HTTPSOptions} from '@atlaspack/types';
 import type {FileSystem} from '@atlaspack/fs';
@@ -13,27 +19,29 @@ import https from 'https';
 import nullthrows from 'nullthrows';
 import {getCertificate, generateCertificate} from './';
 
-type CreateHTTPServerOpts = {
-  listener?: (arg1: HTTPRequest, arg2: HTTPResponse) => void;
-  host?: string;
-} & (
-  | {
-      https: HTTPSOptions | boolean | null | undefined;
-      inputFS: FileSystem;
-      outputFS: FileSystem;
-      cacheDir: FilePath;
-    }
-  | Record<any, any>
-);
+type CreateHTTPServerOpts = {|
+  listener?: (HTTPRequest | HTTPSRequest, HTTPResponse | HTTPSResponse) => void,
+  host?: string,
+  ...
+    | {|
+        https: ?(HTTPSOptions | boolean),
+        inputFS: FileSystem,
+        outputFS: FileSystem,
+        cacheDir: FilePath,
+      |}
+    | {||},
+|};
 
 export type HTTPServer = HTTPOnlyServer | HTTPSServer;
 
 // Creates either an http or https server with an awaitable dispose
 // that closes any connections
-export async function createHTTPServer(options: CreateHTTPServerOpts): Promise<{
-  stop: () => Promise<void>;
-  server: HTTPServer;
-}> {
+export async function createHTTPServer(
+  options: CreateHTTPServerOpts,
+): Promise<{|
+  stop: () => Promise<void>,
+  server: HTTPServer,
+|}> {
   let server;
   if (!options.https) {
     server = http.createServer(options.listener);
@@ -65,23 +73,21 @@ export async function createHTTPServer(options: CreateHTTPServerOpts): Promise<{
   return {
     server,
     stop() {
-      return new Promise(
-        (resolve: () => void, reject: (error?: any) => void) => {
-          for (let socket of nullthrows(sockets)) {
-            socket.destroy();
-          }
-          sockets = new Set();
+      return new Promise((resolve, reject) => {
+        for (let socket of nullthrows(sockets)) {
+          socket.destroy();
+        }
+        sockets = new Set();
 
-          server.close((err) => {
-            if (err != null) {
-              reject(err);
-              return;
-            }
+        server.close((err) => {
+          if (err != null) {
+            reject(err);
+            return;
+          }
 
-            resolve();
-          });
-        },
-      );
+          resolve();
+        });
+      });
     },
   };
 }

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

@@ -1,10 +1,11 @@
-export * from './config';
-export * from './Deferred';
-export * from './generateBuildMetrics';
-export * from './http-server';
-export * from './path';
-export * from './prettyDiagnostic';
-export * from './schema';
+// @flow strict-local
+export type * from './config';
+export type * from './Deferred';
+export type * from './generateBuildMetrics';
+export type * from './http-server';
+export type * from './path';
+export type * from './prettyDiagnostic';
+export type * from './schema';
 
 export {default as countLines} from './countLines';
 export {default as generateBuildMetrics} from './generateBuildMetrics';

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

@@ -1,4 +1,5 @@
-// @ts-expect-error TS7016
+// @flow
+
 import _isURL from 'is-url';
 
 // Matches anchor (ie: #raptors)

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

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

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

@@ -1,6 +1,9 @@
+// @flow strict-local
+
 import crypto from 'crypto';
 
-type Hashable = any;
+// $FlowFixMe
+type Hashable = Object;
 
 export default function objectHash(object: Hashable): string {
   let hash = crypto.createHash('md5');

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

@@ -1,3 +1,5 @@
+// @flow
+
 import open from 'open';
 import {execSync} from 'child_process';
 import logger from '@atlaspack/logger';
@@ -31,7 +33,7 @@ function commandExistsUnixSync(commandName: string) {
         ` && { echo >&1 '${commandName} found'; exit 0; }`,
     );
     return !!stdout;
-  } catch (error: any) {
+  } catch (error) {
     return false;
   }
 }
@@ -52,7 +54,7 @@ export default async function openInBrowser(url: string, browser: string) {
         : undefined;
 
     await open(url, options);
-  } catch (err: any) {
+  } catch (err) {
     logger.error(
       `Unexpected error while opening in browser: ${browser}`,
       '@atlaspack/utils',

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

@@ -1,3 +1,5 @@
+// @flow strict
+
 export default function parseCSSImport(url: string): string {
   if (!/^(~|\.\/|\/)/.test(url)) {
     return './' + url;

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

@@ -1,3 +1,4 @@
+// @flow strict-local
 import type {FilePath} from '@atlaspack/types';
 import path from 'path';
 
@@ -13,7 +14,8 @@ export function normalizeSeparators(filePath: FilePath): FilePath {
 }
 
 export type PathOptions = {
-  noLeadingDotSlash?: boolean;
+  noLeadingDotSlash?: boolean,
+  ...
 };
 
 export function normalizePath(

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

@@ -1,3 +1,5 @@
+// @flow strict-local
+
 export default function prettifyTime(timeInMs: number): string {
   return timeInMs < 1000 ? `${timeInMs}ms` : `${(timeInMs / 1000).toFixed(2)}s`;
 }

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

@@ -1,3 +1,4 @@
+// @flow strict-local
 import type {Diagnostic} from '@atlaspack/diagnostic';
 import type {PluginOptions} from '@atlaspack/types';
 
@@ -5,27 +6,29 @@ import formatCodeFrame from '@atlaspack/codeframe';
 import _mdAnsi from '@atlaspack/markdown-ansi';
 import _chalk from 'chalk';
 import path from 'path';
+// $FlowFixMe
 import _terminalLink from 'terminal-link';
 
 /* eslint-disable import/no-extraneous-dependencies */
+// $FlowFixMe
 import snarkdown from 'snarkdown';
 /* eslint-enable import/no-extraneous-dependencies */
 
-export type FormattedCodeFrame = {
-  location: string;
-  code: string;
-};
+export type FormattedCodeFrame = {|
+  location: string,
+  code: string,
+|};
 
-export type AnsiDiagnosticResult = {
-  message: string;
-  stack: string;
+export type AnsiDiagnosticResult = {|
+  message: string,
+  stack: string,
   /** A formatted string containing all code frames, including their file locations. */
-  codeframe: string;
+  codeframe: string,
   /** A list of code frames with highlighted code and file locations separately. */
-  frames: Array<FormattedCodeFrame>;
-  hints: Array<string>;
-  documentation: string;
-};
+  frames: Array<FormattedCodeFrame>,
+  hints: Array<string>,
+  documentation: string,
+|};
 
 export default async function prettyDiagnostic(
   diagnostic: Diagnostic,
@@ -48,24 +51,18 @@ export default async function prettyDiagnostic(
     format === 'ansi'
       ? _terminalLink
       : // eslint-disable-next-line no-unused-vars
-        (
-          text: string,
-          url: string,
-          _: {
-            fallback: (text: never, url: never) => string;
-          },
-        ) => `<a href="${url}">${text}</a>`;
+        (text, url, _) => `<a href="${url}">${text}</a>`;
   const chalk =
     format === 'ansi'
       ? _chalk
       : {
           gray: {
-            underline: (v: string) =>
+            underline: (v) =>
               `<span style="color: grey; text-decoration: underline;">${v}</span>`,
           },
         };
 
-  let result: AnsiDiagnosticResult = {
+  let result = {
     message:
       md(`**${origin ?? 'unknown'}**: `) +
       (skipFormatting ? message : md(message)),
@@ -95,6 +92,7 @@ export default async function prettyDiagnostic(
           useColor: true,
           syntaxHighlighting: true,
           language:
+            // $FlowFixMe sketchy null checks do not matter here...
             codeFrame.language ||
             (filePath != null ? path.extname(filePath).substr(1) : undefined),
           terminalWidth,
@@ -134,7 +132,7 @@ export default async function prettyDiagnostic(
 
   if (documentationURL != null) {
     result.documentation = terminalLink('Learn more', documentationURL, {
-      fallback: (text: string, url: string) => `${text}: ${url}`,
+      fallback: (text, url) => `${text}: ${url}`,
     });
   }
 

package/src/{progress-message.ts → progress-message.js}

@@ -1,10 +1,9 @@
+// @flow strict-local
 import type {BuildProgressEvent} from '@atlaspack/types';
 
 import path from 'path';
 
-export function getProgressMessage(
-  event: BuildProgressEvent,
-): string | null | undefined {
+export function getProgressMessage(event: BuildProgressEvent): ?string {
   switch (event.phase) {
     case 'transforming':
       return `Building ${path.basename(event.filePath)}...`;

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

@@ -1,3 +1,5 @@
+// @flow strict-local
+
 import type {FilePath, NamedBundle} from '@atlaspack/types';
 
 import path from 'path';
@@ -6,9 +8,7 @@ import {relativePath} from './path';
 export function relativeBundlePath(
   from: NamedBundle,
   to: NamedBundle,
-  opts: {
-    leadingDotSlash: boolean;
-  } = {leadingDotSlash: true},
+  opts: {|leadingDotSlash: boolean|} = {leadingDotSlash: true},
 ): FilePath {
   let fromPath = path.join(from.target.distDir, from.name);
   let toPath = path.join(to.target.distDir, to.name);

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

@@ -1,3 +1,4 @@
+// @flow
 import path from 'path';
 import url from 'url';