package-build-stats 7.3.8 → 8.0.0-beta.1

package/src/utils/build.utils.ts

@@ -1,15 +1,12 @@
 import path from 'path'
 
 const log = require('debug')('bp:worker')
-import webpack, { Entry } from 'webpack'
-import MemoryFS from 'memory-fs'
 import isValidNPMName from 'is-valid-npm-name'
-import { gzipSync } from 'zlib'
 import fs from 'fs'
-import getDependencySizes from '../getDependencySizeTree'
 import getParseTime from '../getParseTime'
-import makeWebpackConfig from '../config/makeWebpackConfig'
 import { performance } from 'perf_hooks'
+import { gzip } from 'node-gzip'
+import { Parcel } from '@parcel/core'
 
 import {
   BuildError,
@@ -20,24 +17,33 @@ import {
 } from '../errors/CustomError'
 import {
   Externals,
-  WebpackError,
   BuildPackageOptions,
   CreateEntryPointOptions,
 } from '../common.types'
 import Telemetry from './telemetry.utils'
+import {
+  printDiagnosticError,
+  updateProjectPeerDependencies,
+} from './common.utils'
+import ThrowableDiagnostic, { Diagnostic } from '@parcel/diagnostic'
+import config from '../config'
+import pAll from 'p-all'
 
 type CompilePackageArgs = {
   name: string
   externals: Externals
-  entry: Entry
+  entry: EntryObject
   debug?: boolean
   minifier: 'terser' | 'esbuild'
+  installPath: string
 }
 
-type CompilePackageReturn = {
-  stats: webpack.Stats
-  error: WebpackError
-  memoryFileSystem: MemoryFS
+type CompileEntryArgs = {
+  name: string
+  externals: Externals
+  entry: any
+  installPath: string
+  measureComposition: boolean
 }
 
 type BuildPackageArgs = {
@@ -47,18 +53,115 @@ type BuildPackageArgs = {
   options: BuildPackageOptions
 }
 
-type WebpackStatsAsset = NonNullable<webpack.Stats.ToJsonOutput['assets']>[0]
+type EntryObject = {
+  [key: string]: string
+}
+
+type CompiledAssetStat = {
+  file: string
+  size: number
+}
+type CompilePackageReturn = {
+  assets: CompiledAssetStat[]
+}
+
+type BuiltAssetStat = {
+  name: string
+  type: string
+  size: number
+  gzip: number
+  parse: { baseParseTime?: number; scriptParseTime?: number } | null
+}
+
+type BuildPackageReturn = {
+  assets: BuiltAssetStat[]
+}
+
+function notEmpty<TValue>(value: TValue | null | undefined): value is TValue {
+  return value !== null && value !== undefined
+}
+
+function isDiagnosticError(error: any): error is ThrowableDiagnostic {
+  return 'diagnostics' in error
+}
+
+function parseMissingModules(errors: Diagnostic[]) {
+  const missingModuleErrors = errors.filter(
+    error =>
+      error.message.startsWith('Failed to resolve') &&
+      error.origin === '@parcel/core'
+  )
+  if (!missingModuleErrors.length) {
+    return []
+  }
+  // There's a better way to get the missing module's name, maybe ?
+  const missingModuleRegex = /Failed to resolve '(.+)' from/
+  const missingModules = missingModuleErrors.map(err => {
+    const matches = err.message.match(missingModuleRegex)
+    if (!matches) {
+      throw new UnexpectedBuildError(
+        'Expected to find a file path in the module not found error, but found none. Regex for this might be out of date.'
+      )
+    }
+    const missingFilePath = matches[1]
+    let packageNameMatch
+    if (missingFilePath.startsWith('@')) {
+      packageNameMatch = missingFilePath.match(/@[^\/]+\/[^\/]+/) // @babel/runtime/object/create -> @babel/runtime
+    } else {
+      packageNameMatch = missingFilePath.match(/[^\/]+/) // babel-runtime/object/create -> babel-runtime
+    }
+    if (!packageNameMatch) {
+      throw new UnexpectedBuildError(
+        'Failed to resolve the missing package name. Regex for this might be out of date.'
+      )
+    }
+    return packageNameMatch[0]
+  })
+  let uniqueMissingModules = Array.from(new Set(missingModules))
+  uniqueMissingModules = uniqueMissingModules.filter(
+    mod => !mod.startsWith(`${uniqueMissingModules[0]}/`)
+  )
+  return uniqueMissingModules
+}
+
+async function getAssetStats(
+  assets: CompiledAssetStat[],
+  options: BuildPackageOptions
+) {
+  const getAssetStats = async (asset: CompiledAssetStat) => {
+    if (!asset.file) return null
+    const bundleContents = fs.readFileSync(asset.file, 'utf8')
+    let parseTimes = null
+    if (options.calcParse) {
+      parseTimes = getParseTime(bundleContents)
+    }
+    const gzipSize = (await gzip(bundleContents)).length
+    const { ext, name } = path.parse(asset.file)
+    return {
+      name: name,
+      type: ext.slice(1),
+      size: asset.size,
+      gzip: gzipSize,
+      parse: parseTimes,
+    }
+  }
+  const assetStatsPromises = assets
+    .filter(asset => !!asset.file)
+    .map(getAssetStats)
+
+  const assetStats = (await Promise.all(assetStatsPromises)).filter(notEmpty)
 
-const BuildUtils = {
-  createEntryPoint(
+  return assetStats
+}
+
+class BuildUtils {
+  static createEntryPoint(
     packageName: string,
     installPath: string,
     options: CreateEntryPointOptions
   ) {
-    const entryPath = path.join(
-      installPath,
-      options.entryFilename || 'index.js'
-    )
+    const entryFilename = options.entryFilename || 'index.js'
+    const entryPath = path.join(installPath, entryFilename)
 
     let importStatement: string
 
@@ -83,113 +186,127 @@ const BuildUtils = {
         importStatement = `const p = require('${packageName}'); console.log(p)`
       }
     }
-
     try {
       fs.writeFileSync(entryPath, importStatement, 'utf-8')
       return entryPath
     } catch (err) {
       throw new EntryPointError(err)
     }
-  },
+  }
 
-  compilePackage({
-    name,
+  static async compileEntry({
     entry,
     externals,
-    debug,
-    minifier,
-  }: CompilePackageArgs) {
-    const startTime = performance.now()
-    const compiler = webpack(
-      makeWebpackConfig({
-        packageName: name,
-        entry,
-        externals,
-        debug,
-        minifier,
-      })
+    installPath,
+    measureComposition,
+  }: CompileEntryArgs): Promise<CompilePackageReturn> {
+    await updateProjectPeerDependencies(
+      installPath,
+      Object.fromEntries(
+        [...externals.externalBuiltIns, ...externals.externalPackages].map(
+          pack => [pack, '*']
+        )
+      )
     )
-    const memoryFileSystem = new MemoryFS()
-    compiler.outputFileSystem = memoryFileSystem
-
-    return new Promise<CompilePackageReturn>(resolve => {
-      compiler.run((err, stats) => {
-        const error = (err as unknown) as WebpackError // Webpack types incorrect
-        // stats object can be empty if there are build errors
-        resolve({ stats, error, memoryFileSystem })
-
-        if (error) {
-          console.error(error)
-          Telemetry.compilePackage(name, false, startTime, { minifier }, error)
-        } else {
-          Telemetry.compilePackage(name, true, startTime, { minifier })
-        }
-      })
-    })
-  },
 
-  _parseMissingModules(errors: Array<WebpackError>) {
-    const missingModuleErrors = errors.filter(
-      error => error.name === 'ModuleNotFoundError'
-    )
+    // We use this as a way to pass options to the reporter plugin
+    process.env.MEASURE_COMPOSISION = `${measureComposition}`
+
+    let bundler = new Parcel({
+      entries: [entry],
+      mode: 'production',
+      env: Object.assign(Object.assign({}, process.env), {
+        NODE_ENV: 'production',
+      }),
+      defaultConfig: '@parcel/config-default',
+      shouldAutoInstall: false,
+      cacheDir: path.join(config.tmp, 'parcel-cache'),
+      config: require.resolve(path.join(__dirname, '..', '..', '.parcelrc')),
+      shouldDisableCache: true,
+      shouldContentHash: false,
+      defaultTargetOptions: {
+        sourceMaps: measureComposition,
+        outputFormat: 'global',
+        shouldOptimize: true,
+        isLibrary: false,
+        engines: {
+          browsers: [
+            'last 5 Chrome versions',
+            'last 5 Firefox versions',
+            'Safari >= 9',
+            'edge >= 12',
+          ],
+        },
+      },
+    })
 
-    if (!missingModuleErrors.length) {
-      return []
+    const assets = []
+    let { bundleGraph } = await bundler.run()
+    for (let bundle of bundleGraph.getBundles()) {
+      assets.push({
+        file: bundle.filePath,
+        size: bundle.stats.size,
+      })
     }
 
-    // There's a better way to get the missing module's name, maybe ?
-    const missingModuleRegex = /Can't resolve '(.+)' in/
+    return { assets }
+  }
 
-    const missingModules = missingModuleErrors.map(err => {
-      const matches = err.error.toString().match(missingModuleRegex)
+  static async compilePackage({
+    name,
+    entry,
+    externals,
+    minifier,
+    installPath,
+  }: CompilePackageArgs): Promise<CompilePackageReturn> {
+    const startTime = performance.now()
 
-      if (!matches) {
-        throw new UnexpectedBuildError(
-          'Expected to find a file path in the module not found error, but found none. Regex for this might be out of date.'
-        )
-      }
+    let allAssets: CompiledAssetStat[] = []
+    const entries = Object.values(entry)
+    const entryPromises = entries.map(entry => async () => {
+      const { assets } = await BuildUtils.compileEntry({
+        name,
+        entry,
+        measureComposition: entries.length === 1,
+        externals,
+        installPath,
+      })
+      log('Building entry %s', entry)
+      allAssets = [...allAssets, ...assets]
+    })
 
-      const missingFilePath = matches[1]
-      let packageNameMatch
-      if (missingFilePath.startsWith('@')) {
-        packageNameMatch = missingFilePath.match(/@[^\/]+\/[^\/]+/) // @babel/runtime/object/create -> @babel/runtime
+    try {
+      await pAll(entryPromises, { concurrency: 1 })
+      Telemetry.compilePackage(name, true, startTime, { minifier })
+      return { assets: allAssets }
+    } catch (err) {
+      if (isDiagnosticError(err)) {
+        printDiagnosticError(err)
       } else {
-        packageNameMatch = missingFilePath.match(/[^\/]+/) // babel-runtime/object/create -> babel-runtime
-      }
-
-      if (!packageNameMatch) {
-        throw new UnexpectedBuildError(
-          'Failed to resolve the missing package name. Regex for this might be out of date.'
-        )
+        console.error(err)
       }
+      Telemetry.compilePackage(name, false, startTime, { minifier }, err)
+      throw err
+    }
+  }
 
-      return packageNameMatch[0]
-    })
-
-    let uniqueMissingModules = Array.from(new Set(missingModules))
-    uniqueMissingModules = uniqueMissingModules.filter(
-      mod => !mod.startsWith(`${uniqueMissingModules[0]}/`)
-    )
-
-    return uniqueMissingModules
-  },
-
-  async buildPackage({
+  static async buildPackage({
     name,
     installPath,
     externals,
     options,
-  }: BuildPackageArgs) {
-    let entry: Entry = {}
+  }: BuildPackageArgs): Promise<BuildPackageReturn> {
+    let entry: EntryObject = {}
 
     if (options.splitCustomImports) {
       if (!options.customImports || !options.customImports.length) {
         return { assets: [] }
       }
-      options.customImports.forEach(importt => {
+
+      options.customImports.forEach((importt: string) => {
         entry[importt] = BuildUtils.createEntryPoint(name, installPath, {
           customImports: [importt],
-          entryFilename: importt,
+          entryFilename: `${importt}.js`,
           esm: true,
         })
       })
@@ -201,139 +318,49 @@ const BuildUtils = {
     }
 
     log('build start %s', name)
-    const { stats, error, memoryFileSystem } = await BuildUtils.compilePackage({
-      name,
-      entry,
-      externals,
-      debug: options.debug,
-      minifier: options.minifier,
-    })
 
-    log('build end %s', name)
-
-    const jsonStatsStartTime = performance.now()
-    let jsonStats = stats.toJson({
-      assets: true,
-      children: false,
-      chunks: false,
-      chunkGroups: false,
-      chunkModules: false,
-      chunkOrigins: false,
-      modules: true,
-      errorDetails: false,
-      entrypoints: false,
-      reasons: false,
-      maxModules: 500,
-      performance: false,
-      source: true,
-      depth: true,
-      providedExports: true,
-      warnings: false,
-      modulesSort: 'depth',
-    })
-
-    if (!jsonStats) {
-      Telemetry.parseWebpackStats(name, false, jsonStatsStartTime)
-      throw new UnexpectedBuildError(
-        'Expected webpack json stats to be non-null, but was null'
-      )
-    } else {
-      Telemetry.parseWebpackStats(name, true, jsonStatsStartTime)
-    }
-
-    if (error && !stats) {
-      throw new BuildError(error)
-    } else if (stats.compilation.errors && stats.compilation.errors.length) {
-      const missingModules = BuildUtils._parseMissingModules(
-        stats.compilation.errors
-      )
-
-      if (missingModules.length) {
-        if (missingModules.length === 1 && missingModules[0] === name) {
-          throw new EntryPointError(
-            stats.compilation.errors.map(err => err.toString())
-          )
-        } else {
-          throw new MissingDependencyError(
-            stats.compilation.errors.map(err => err.toString()),
-            { missingModules }
-          )
-        }
-      } else if (jsonStats.errors && jsonStats.errors.length > 0) {
-        if (
-          jsonStats.errors.some(error =>
-            error.includes("Unexpected character '#'")
-          )
-        ) {
-          throw new CLIBuildError(jsonStats.errors)
-        } else {
-          throw new BuildError(jsonStats.errors)
-        }
-      } else {
-        throw new UnexpectedBuildError(
-          'The webpack stats object was unexpectedly empty'
-        )
-      }
-    } else {
-      const getAssetStats = (asset: WebpackStatsAsset) => {
-        const bundle = path.join(process.cwd(), 'dist', asset.name)
-        const bundleContents = memoryFileSystem.readFileSync(bundle)
-        let parseTimes = null
-        if (options.calcParse) {
-          parseTimes = getParseTime(bundleContents)
-        }
-
-        const gzip = gzipSync(bundleContents, {}).length
-        const matches = asset.name.match(/(.+?)\.bundle\.(.+)$/)
-
-        if (!matches) {
-          throw new UnexpectedBuildError(
-            'Found an asset without the `.bundle` suffix. ' +
-              'A loader customization might be needed to recognize this asset type' +
-              asset.name
-          )
-        }
-
-        const [, entryName, extension] = matches
-
-        return {
-          name: entryName,
-          type: extension,
-          size: asset.size,
-          gzip,
-          parse: parseTimes,
-        }
-      }
-
-      const assetsGzipStartTime = performance.now()
-      const assetStats = jsonStats?.assets
-        ?.filter(asset => !asset.chunkNames.includes('runtime'))
-        .filter(asset => !asset.name.endsWith('LICENSE.txt'))
-        .map(getAssetStats)
-      Telemetry.assetsGZIPParseTime(name, assetsGzipStartTime)
+    try {
+      const { assets } = await BuildUtils.compilePackage({
+        name,
+        entry,
+        installPath,
+        externals,
+        debug: options.debug,
+        minifier: options.minifier,
+      })
 
-      log('build result %O', assetStats)
+      log('build end %s', name)
+      log('after compile assets %o', assets)
 
+      const assetStats = await getAssetStats(assets, options)
       return {
         assets: assetStats || [],
         ...(options.includeDependencySizes && {
-          dependencySizes: await getDependencySizes(
-            name,
-            jsonStats,
-            options.minifier
-          ),
+          dependencySizes: require(path.join(installPath, 'composition.json')),
         }),
       }
+    } catch (error) {
+      if (isDiagnosticError(error)) {
+        const missingModules = parseMissingModules(error.diagnostics)
+        if (missingModules.length) {
+          if (missingModules.length === 1 && missingModules[0] === name) {
+            throw new EntryPointError(error.diagnostics)
+          } else {
+            throw new MissingDependencyError(error.diagnostics, {
+              missingModules,
+            })
+          }
+        }
+      }
+      throw new BuildError(error)
     }
-  },
-  async buildPackageIgnoringMissingDeps({
-    name,
-    externals,
-    installPath,
-    options,
-  }: BuildPackageArgs) {
+  }
+
+  static async buildPackageIgnoringMissingDeps(
+    { name, externals, installPath, options }: BuildPackageArgs,
+    buildIteration: number
+  ): Promise<BuildPackageReturn> {
     const buildStartTime = performance.now()
-    let buildIteration = 1
 
     try {
       const buildResult = await BuildUtils.buildPackage({
@@ -351,8 +378,8 @@ const BuildUtils = {
       buildIteration++
       if (
         e instanceof MissingDependencyError &&
-        e.missingModules.length <= 6 &&
-        e.missingModules.every(mod => isValidNPMName(mod))
+        e.missingModules.every(mod => isValidNPMName(mod)) &&
+        buildIteration < 4
       ) {
         const { missingModules } = e.extra
         const newExternals = {
@@ -364,12 +391,15 @@ const BuildUtils = {
           name,
           missingModules
         )
-        const rebuiltResult = await BuildUtils.buildPackage({
-          name,
-          externals: newExternals,
-          installPath,
-          options,
-        })
+        const rebuiltResults = await BuildUtils.buildPackageIgnoringMissingDeps(
+          {
+            name,
+            externals: newExternals,
+            installPath,
+            options,
+          },
+          buildIteration
+        )
 
         Telemetry.buildPackage(name, true, buildStartTime, {
           ...options,
@@ -377,10 +407,7 @@ const BuildUtils = {
           missingModules,
         })
 
-        return {
-          ignoredMissingDependencies: missingModules,
-          ...rebuiltResult,
-        }
+        return rebuiltResults
       } else {
         Telemetry.buildPackage(
           name,
@@ -395,6 +422,7 @@ const BuildUtils = {
         throw e
       }
     }
-  },
+  }
 }
+
 export default BuildUtils