@atlaspack/utils 2.14.5-canary.36 → 2.14.5-canary.360

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

@@ -1,41 +1,39 @@
-// @flow strict-local
 import type {Diagnostic} from '@atlaspack/diagnostic';
-import type {PluginOptions} from '@atlaspack/types';
+import type {PluginOptions} from '@atlaspack/types-internal';
 
 import formatCodeFrame from '@atlaspack/codeframe';
+import logger from '@atlaspack/logger';
 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(
+export function prettyDiagnosticSync(
   diagnostic: Diagnostic,
   options?: PluginOptions,
   terminalWidth?: number,
   format: 'ansi' | 'html' = 'ansi',
-): Promise<AnsiDiagnosticResult> {
+): AnsiDiagnosticResult {
   let {
     origin,
     message,
@@ -51,18 +49,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)),
@@ -83,7 +87,16 @@ export default async function prettyDiagnostic(
       let highlights = codeFrame.codeHighlights;
       let code = codeFrame.code;
       if (code == null && options && filePath != null) {
-        code = await options.inputFS.readFile(filePath, 'utf8');
+        try {
+          code = options.inputFS.readFileSync(filePath, 'utf8');
+        } catch (e) {
+          // In strange cases this can fail and hide the underlying error.
+          logger.warn({
+            origin: '@atlaspack/utils',
+            message: `Failed to read file for generating codeframe: "${filePath}"`,
+            skipFormatting: true,
+          });
+        }
       }
 
       let formattedCodeFrame = '';
@@ -92,7 +105,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,9 +144,20 @@ 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}`,
     });
   }
 
   return result;
 }
+
+export default function prettyDiagnostic(
+  diagnostic: Diagnostic,
+  options?: PluginOptions,
+  terminalWidth?: number,
+  format: 'ansi' | 'html' = 'ansi',
+): Promise<AnsiDiagnosticResult> {
+  return Promise.resolve(
+    prettyDiagnosticSync(diagnostic, options, terminalWidth, format),
+  );
+}

package/src/progress-message.ts

@@ -0,0 +1,43 @@
+import type {BuildProgressEvent} from '@atlaspack/types-internal';
+
+import path from 'path';
+
+export function getProgressMessage(
+  event: BuildProgressEvent,
+): string | null | undefined {
+  switch (event.phase) {
+    case 'transforming':
+      return `Building ${path.basename(event.filePath)}...`;
+
+    case 'bundling':
+      return 'Bundling...';
+
+    case 'packaging':
+      return `Packaging ${event.bundle.displayName}...`;
+
+    case 'optimizing':
+      return `Optimizing ${event.bundle.displayName}...`;
+
+    case 'packagingAndOptimizing': {
+      return getPackageProgressMessage(
+        event.completeBundles,
+        event.totalBundles,
+      );
+    }
+  }
+
+  return null;
+}
+
+export function getPackageProgressMessage(
+  completeBundles: number,
+  totalBundles: number,
+): string {
+  let percent = Math.floor((completeBundles / totalBundles) * 100);
+  let completeStr = completeBundles.toString();
+  let totalStr = totalBundles.toString();
+
+  let displayBundles = completeStr.padStart(totalStr.length, ' ');
+
+  return `Packaging bundles ${displayBundles}/${totalBundles} (${percent}%)`;
+}

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

@@ -1,6 +1,4 @@
-// @flow strict-local
-
-import type {FilePath, NamedBundle} from '@atlaspack/types';
+import type {FilePath, NamedBundle} from '@atlaspack/types-internal';
 
 import path from 'path';
 import {relativePath} 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,6 +1,4 @@
-// @flow strict-local
-
-import type SourceMap from '@parcel/source-map';
+import type SourceMap from '@atlaspack/source-map';
 import type {
   Async,
   Blob,
@@ -8,9 +6,8 @@ import type {
   BundleGraph,
   Dependency,
   NamedBundle,
-} from '@atlaspack/types';
+} from '@atlaspack/types-internal';
 import {performStringReplacements} from '@atlaspack/rust';
-import {getFeatureFlag} from '@atlaspack/feature-flags';
 
 import {Readable} from 'stream';
 import nullthrows from 'nullthrows';
@@ -20,7 +17,10 @@ import {bufferStream, relativeBundlePath, urlJoin} from './';
 
 type ReplacementMap = Map<
   string /* dependency id */,
-  {|from: string, to: string|},
+  {
+    from: string;
+    to: string;
+  }
 >;
 
 /*
@@ -35,18 +35,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);
@@ -70,7 +73,10 @@ export function replaceURLReferences({
       continue;
     }
 
-    if (resolved.bundleBehavior === 'inline') {
+    if (
+      resolved.bundleBehavior === 'inline' ||
+      resolved.bundleBehavior === 'inlineIsolated'
+    ) {
       // If a bundle is inline, it should be replaced with inline contents,
       // not a URL.
       continue;
@@ -102,24 +108,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);
@@ -128,7 +142,10 @@ export async function replaceInlineReferences({
 
   for (let dependency of dependencies) {
     let entryBundle = bundleGraph.getReferencedBundle(dependency, bundle);
-    if (entryBundle?.bundleBehavior !== 'inline') {
+    if (
+      entryBundle?.bundleBehavior !== 'inline' &&
+      entryBundle?.bundleBehavior !== 'inlineIsolated'
+    ) {
       continue;
     }
 
@@ -162,13 +179,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,21 +228,17 @@ 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')) {
-    let replacementList = Array.from(replacements.values());
+  let replacementList = Array.from(replacements.values());
 
-    if (replacementList.length > 0) {
-      finalContents = performStringReplacements(contents, replacementList);
-    }
-  } else {
-    for (let {from, to} of replacements.values()) {
-      // Perform replacement
-      finalContents = finalContents.split(from).join(to);
-    }
+  if (replacementList.length > 0) {
+    finalContents = performStringReplacements(contents, replacementList);
   }
 
   return {