@atlaspack/utils 2.17.3 → 2.17.4-typescript-5ad950d33.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,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> {

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

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

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

@@ -1,11 +1,10 @@
-// @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 * from './config';
+export * from './Deferred';
+export * from './generateBuildMetrics';
+export * from './http-server';
+export * from './path';
+export * from './prettyDiagnostic';
+export * from './schema';
 
 export {default as countLines} from './countLines';
 export {default as generateBuildMetrics} from './generateBuildMetrics';

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

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

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

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

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

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

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

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

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

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

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

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

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

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