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

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`;
 }

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

@@ -1,4 +1,3 @@
-// @flow strict-local
 import type {Diagnostic} from '@atlaspack/diagnostic';
 import type {PluginOptions} from '@atlaspack/types';
 
@@ -6,29 +5,27 @@ 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,
@@ -51,18 +48,24 @@ export default async function prettyDiagnostic(
     format === 'ansi'
       ? _terminalLink
       : // eslint-disable-next-line no-unused-vars
-        (text, url, _) => `<a href="${url}">${text}</a>`;
+        (
+          text: string,
+          url: string,
+          _: {
+            fallback: (text: never, url: never) => string;
+          },
+        ) => `<a href="${url}">${text}</a>`;
   const chalk =
     format === 'ansi'
       ? _chalk
       : {
           gray: {
-            underline: (v) =>
+            underline: (v: string) =>
               `<span style="color: grey; text-decoration: underline;">${v}</span>`,
           },
         };
 
-  let result = {
+  let result: AnsiDiagnosticResult = {
     message:
       md(`**${origin ?? 'unknown'}**: `) +
       (skipFormatting ? message : md(message)),
@@ -92,7 +95,6 @@ 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,
@@ -132,7 +134,7 @@ export default async function prettyDiagnostic(
 
   if (documentationURL != null) {
     result.documentation = terminalLink('Learn more', documentationURL, {
-      fallback: (text, url) => `${text}: ${url}`,
+      fallback: (text: string, url: string) => `${text}: ${url}`,
     });
   }
 

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

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

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

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import type {FilePath, NamedBundle} from '@atlaspack/types';
 
 import path from 'path';
@@ -8,7 +6,9 @@ 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.js → relativeUrl.ts}

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

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

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import type SourceMap from '@parcel/source-map';
 import type {
   Async,
@@ -20,7 +18,10 @@ import {bufferStream, relativeBundlePath, urlJoin} from './';
 
 type ReplacementMap = Map<
   string /* dependency id */,
-  {|from: string, to: string|},
+  {
+    from: string;
+    to: string;
+  }
 >;
 
 /*
@@ -35,18 +36,21 @@ export function replaceURLReferences({
   bundleGraph,
   contents,
   map,
-  getReplacement = (s) => s,
+  getReplacement = (s: string) => s,
   relative = true,
-}: {|
-  bundle: NamedBundle,
-  bundleGraph: BundleGraph<NamedBundle>,
-  contents: string,
-  relative?: boolean,
-  map?: ?SourceMap,
-  getReplacement?: (string) => string,
-|}): {|+contents: string, +map: ?SourceMap|} {
+}: {
+  bundle: NamedBundle;
+  bundleGraph: BundleGraph<NamedBundle>;
+  contents: string;
+  relative?: boolean;
+  map?: SourceMap | null | undefined;
+  getReplacement?: (arg1: string) => string;
+}): {
+  readonly contents: string;
+  readonly map: SourceMap | null | undefined;
+} {
   let replacements = new Map();
-  let urlDependencies = [];
+  let urlDependencies: Array<Dependency> = [];
   bundle.traverse((node) => {
     if (node.type === 'dependency' && node.value.specifierType === 'url') {
       urlDependencies.push(node.value);
@@ -102,24 +106,32 @@ export async function replaceInlineReferences({
   map,
   getInlineReplacement,
   getInlineBundleContents,
-}: {|
-  bundle: Bundle,
-  bundleGraph: BundleGraph<NamedBundle>,
-  contents: string,
+}: {
+  bundle: Bundle;
+  bundleGraph: BundleGraph<NamedBundle>;
+  contents: string;
   getInlineReplacement: (
-    Dependency,
-    ?'string',
-    string,
-  ) => {|from: string, to: string|},
+    arg1: Dependency,
+    arg2: 'string' | null | undefined,
+    arg3: string,
+  ) => {
+    from: string;
+    to: string;
+  };
   getInlineBundleContents: (
-    Bundle,
-    BundleGraph<NamedBundle>,
-  ) => Async<{|contents: Blob|}>,
-  map?: ?SourceMap,
-|}): Promise<{|+contents: string, +map: ?SourceMap|}> {
+    arg1: Bundle,
+    arg2: BundleGraph<NamedBundle>,
+  ) => Async<{
+    contents: Blob;
+  }>;
+  map?: SourceMap | null | undefined;
+}): Promise<{
+  readonly contents: string;
+  readonly map: SourceMap | null | undefined;
+}> {
   let replacements = new Map();
 
-  let dependencies = [];
+  let dependencies: Array<Dependency> = [];
   bundle.traverse((node) => {
     if (node.type === 'dependency') {
       dependencies.push(node.value);
@@ -162,13 +174,16 @@ export function getURLReplacement({
   toBundle,
   relative,
   getReplacement,
-}: {|
-  dependency: Dependency,
-  fromBundle: NamedBundle,
-  toBundle: NamedBundle,
-  relative: boolean,
-  getReplacement?: (string) => string,
-|}): {|from: string, to: string|} {
+}: {
+  dependency: Dependency;
+  fromBundle: NamedBundle;
+  toBundle: NamedBundle;
+  relative: boolean;
+  getReplacement?: (arg1: string) => string;
+}): {
+  from: string;
+  to: string;
+} {
   let to;
 
   let orig = URL.parse(dependency.specifier);
@@ -208,8 +223,11 @@ export function getURLReplacement({
 function performReplacement(
   replacements: ReplacementMap,
   contents: string,
-  map?: ?SourceMap,
-): {|+contents: string, +map: ?SourceMap|} {
+  map?: SourceMap | null,
+): {
+  readonly contents: string;
+  readonly map: SourceMap | null | undefined;
+} {
   let finalContents = contents;
 
   if (getFeatureFlag('inlineStringReplacementPerf')) {