@parcel/utils 2.0.0-nightly.97 → 2.1.0

package/src/alternatives.js

@@ -0,0 +1,143 @@
+// @flow
+import path from 'path';
+import type {FileSystem} from '@parcel/fs';
+import {fuzzySearch} from './schema';
+import {relativePath} from './path';
+import {resolveConfig} from './config';
+
+export async function findAlternativeNodeModules(
+  fs: FileSystem,
+  moduleName: string,
+  dir: string,
+): Promise<Array<string>> {
+  let potentialModules: Array<string> = [];
+  let root = path.parse(dir).root;
+  let isOrganisationModule = moduleName.startsWith('@');
+
+  while (dir !== root) {
+    // Skip node_modules directories
+    if (path.basename(dir) === 'node_modules') {
+      dir = path.dirname(dir);
+    }
+
+    try {
+      let modulesDir = path.join(dir, 'node_modules');
+      let stats = await fs.stat(modulesDir);
+      if (stats.isDirectory()) {
+        let dirContent = (await fs.readdir(modulesDir)).sort();
+
+        // Filter out the modules that interest us
+        let modules = dirContent.filter(i =>
+          isOrganisationModule ? i.startsWith('@') : !i.startsWith('@'),
+        );
+
+        // If it's an organisation module, loop through all the modules of that organisation
+        if (isOrganisationModule) {
+          await Promise.all(
+            modules.map(async item => {
+              let orgDirPath = path.join(modulesDir, item);
+              let orgDirContent = (await fs.readdir(orgDirPath)).sort();
+
+              // Add all org packages
+              potentialModules.push(...orgDirContent.map(i => `${item}/${i}`));
+            }),
+          );
+        }
+      }
+    } catch (err) {
+      // ignore
+    }
+
+    // Move up a directory
+    dir = path.dirname(dir);
+  }
+
+  return fuzzySearch(potentialModules.sort(), moduleName).slice(0, 2);
+}
+
+async function findAllFilesUp({
+  fs,
+  dir,
+  root,
+  basedir,
+  maxlength,
+  collected,
+  leadingDotSlash = true,
+  includeDirectories = true,
+}: {|
+  fs: FileSystem,
+  dir: string,
+  root: string,
+  basedir: string,
+  maxlength: number,
+  collected: Array<string>,
+  leadingDotSlash?: boolean,
+  includeDirectories?: boolean,
+|}): Promise<mixed> {
+  let dirContent = (await fs.readdir(dir)).sort();
+  return Promise.all(
+    dirContent.map(async item => {
+      let fullPath = path.join(dir, item);
+      let relativeFilePath = relativePath(basedir, fullPath, leadingDotSlash);
+      if (relativeFilePath.length < maxlength) {
+        let stats = await fs.stat(fullPath);
+        let isDir = stats.isDirectory();
+        if ((isDir && includeDirectories) || stats.isFile()) {
+          collected.push(relativeFilePath);
+        }
+
+        // If it's a directory, run over each item within said directory...
+        if (isDir) {
+          return findAllFilesUp({
+            fs,
+            dir: fullPath,
+            root,
+            basedir,
+            maxlength,
+            collected,
+          });
+        }
+      }
+    }),
+  );
+}
+
+export async function findAlternativeFiles(
+  fs: FileSystem,
+  fileSpecifier: string,
+  dir: string,
+  projectRoot: string,
+  leadingDotSlash?: boolean = true,
+  includeDirectories?: boolean = true,
+  includeExtension?: boolean = false,
+): Promise<Array<string>> {
+  let potentialFiles: Array<string> = [];
+  // Find our root, we won't recommend files above the package root as that's bad practise
+  let pkg = await resolveConfig(
+    fs,
+    path.join(dir, 'index'),
+    ['package.json'],
+    projectRoot,
+  );
+
+  let pkgRoot = pkg ? path.dirname(pkg) : projectRoot;
+  await findAllFilesUp({
+    fs,
+    dir: pkgRoot,
+    root: pkgRoot,
+    basedir: dir,
+    maxlength: fileSpecifier.length + 10,
+    collected: potentialFiles,
+    leadingDotSlash,
+    includeDirectories,
+  });
+
+  if (path.extname(fileSpecifier) === '' && !includeExtension) {
+    potentialFiles = potentialFiles.map(p => {
+      let ext = path.extname(p);
+      return ext.length > 0 ? p.slice(0, -ext.length) : p;
+    });
+  }
+
+  return fuzzySearch(potentialFiles, fileSpecifier).slice(0, 2);
+}

package/src/ansi-html.js

@@ -1,5 +1,5 @@
-// @flow
-import ansiHTML from 'ansi-html';
+// @flow strict-local
+import ansiHTML from 'ansi-html-community';
 import {escapeHTML} from './escape-html';
 
 export function ansiHtml(ansi: string): string {

package/src/blob.js

@@ -2,16 +2,17 @@
 
 import type {Blob} from '@parcel/types';
 
-import {bufferStream} from '../';
+import {Buffer} from 'buffer';
+import {bufferStream} from './';
 import {Readable} from 'stream';
 
 export function blobToBuffer(blob: Blob): Promise<Buffer> {
   if (blob instanceof Readable) {
     return bufferStream(blob);
   } else if (blob instanceof Buffer) {
-    return Buffer.from(blob);
+    return Promise.resolve(Buffer.from(blob));
   } else {
-    return Buffer.from(blob, 'utf8');
+    return Promise.resolve(Buffer.from(blob, 'utf8'));
   }
 }
 

package/src/bundle-url.js

@@ -1,7 +1,7 @@
 // @flow strict-local
 
 let bundleURL: ?string = null;
-function getBundleURLCached() {
+function getBundleURLCached(): string {
   if (bundleURL == null) {
     bundleURL = _getBundleURL();
   }

package/src/collection.js

@@ -4,28 +4,16 @@ export function unique<T>(array: Array<T>): Array<T> {
   return [...new Set(array)];
 }
 
-export function flatMap<T, U>(
-  array: Array<T>,
-  projectFn: (T, number, Array<T>) => Array<U>,
-): Array<U> {
-  let out = [];
-
-  for (let arr of array.map(projectFn)) {
-    out.push(...arr);
-  }
-  return out;
-}
-
 export function objectSortedEntries(obj: {
   +[string]: mixed,
-  ...,
+  ...
 }): Array<[string, mixed]> {
   return Object.entries(obj).sort(([keyA], [keyB]) => keyA.localeCompare(keyB));
 }
 
 export function objectSortedEntriesDeep(object: {
   +[string]: mixed,
-  ...,
+  ...
 }): Array<[string, mixed]> {
   let sortedEntries = objectSortedEntries(object);
   for (let i = 0; i < sortedEntries.length; i++) {
@@ -55,3 +43,15 @@ export function setDifference<T>(a: Set<T>, b: Set<T>): Set<T> {
   }
   return difference;
 }
+
+export function setIntersect<T>(a: Set<T>, b: Set<T>): void {
+  for (let entry of a) {
+    if (!b.has(entry)) {
+      a.delete(entry);
+    }
+  }
+}
+
+export function setUnion<T>(a: Iterable<T>, b: Iterable<T>): Set<T> {
+  return new Set([...a, ...b]);
+}

package/src/config.js

@@ -2,87 +2,137 @@
 
 import type {ConfigResult, File, FilePath} from '@parcel/types';
 import type {FileSystem} from '@parcel/fs';
+import ThrowableDiagnostic from '@parcel/diagnostic';
 import path from 'path';
 import clone from 'clone';
+import {parse as json5} from 'json5';
+import {parse as toml} from '@iarna/toml';
+import LRU from 'lru-cache';
 
-type ConfigOutput = {|
+export type ConfigOutput = {|
   config: ConfigResult,
   files: Array<File>,
 |};
 
-type ConfigOptions = {|
+export type ConfigOptions = {|
   parse?: boolean,
+  parser?: string => any,
 |};
 
-const PARSERS = {
-  json: require('json5').parse,
-  toml: require('@iarna/toml').parse,
-};
-
-const existsCache = new Map();
+const configCache = new LRU<FilePath, ConfigOutput>({max: 500});
+const resolveCache = new Map();
 
-export async function resolveConfig(
+export function resolveConfig(
   fs: FileSystem,
   filepath: FilePath,
   filenames: Array<FilePath>,
-  opts: ?ConfigOptions,
-  root: FilePath = path.parse(filepath).root,
-): Promise<FilePath | null> {
-  filepath = await fs.realpath(path.dirname(filepath));
-
-  // Don't traverse above the module root
-  if (filepath === root || path.basename(filepath) === 'node_modules') {
-    return null;
+  projectRoot: FilePath,
+): Promise<?FilePath> {
+  // Cache the result of resolving config for this directory.
+  // This is automatically invalidated at the end of the current build.
+  let key = path.dirname(filepath) + filenames.join(',');
+  let cached = resolveCache.get(key);
+  if (cached !== undefined) {
+    return Promise.resolve(cached);
   }
 
-  for (const filename of filenames) {
-    let file = path.join(filepath, filename);
-    if ((await fs.exists(file)) && (await fs.stat(file)).isFile()) {
-      return file;
-    }
-  }
+  let resolved = fs.findAncestorFile(
+    filenames,
+    path.dirname(filepath),
+    projectRoot,
+  );
+  resolveCache.set(key, resolved);
+  return Promise.resolve(resolved);
+}
 
-  return resolveConfig(fs, filepath, filenames, opts);
+export function resolveConfigSync(
+  fs: FileSystem,
+  filepath: FilePath,
+  filenames: Array<FilePath>,
+  projectRoot: FilePath,
+): ?FilePath {
+  return fs.findAncestorFile(filenames, path.dirname(filepath), projectRoot);
 }
 
 export async function loadConfig(
   fs: FileSystem,
   filepath: FilePath,
   filenames: Array<FilePath>,
+  projectRoot: FilePath,
   opts: ?ConfigOptions,
 ): Promise<ConfigOutput | null> {
-  let configFile = await resolveConfig(fs, filepath, filenames, opts);
+  let parse = opts?.parse ?? true;
+  let configFile = await resolveConfig(fs, filepath, filenames, projectRoot);
   if (configFile) {
+    let cachedOutput = configCache.get(String(parse) + configFile);
+    if (cachedOutput) {
+      return cachedOutput;
+    }
+
     try {
       let extname = path.extname(configFile).slice(1);
       if (extname === 'js') {
-        return {
+        let output = {
           // $FlowFixMe
           config: clone(require(configFile)),
           files: [{filePath: configFile}],
         };
+
+        configCache.set(configFile, output);
+        return output;
       }
 
       let configContent = await fs.readFile(configFile, 'utf8');
-      if (!configContent) {
-        return null;
-      }
 
       let config;
-      if (opts && opts.parse === false) {
+      if (parse === false) {
         config = configContent;
       } else {
-        let parse = PARSERS[extname] || PARSERS.json;
-        config = parse(configContent);
+        let parse = opts?.parser ?? getParser(extname);
+        try {
+          config = parse(configContent);
+        } catch (e) {
+          if (extname !== '' && extname !== 'json') {
+            throw e;
+          }
+
+          let pos = {
+            line: e.lineNumber,
+            column: e.columnNumber,
+          };
+
+          throw new ThrowableDiagnostic({
+            diagnostic: {
+              message: `Failed to parse ${path.basename(configFile)}`,
+              origin: '@parcel/utils',
+              codeFrames: [
+                {
+                  language: 'json5',
+                  filePath: configFile,
+                  code: configContent,
+                  codeHighlights: [
+                    {
+                      start: pos,
+                      end: pos,
+                      message: e.message,
+                    },
+                  ],
+                },
+              ],
+            },
+          });
+        }
       }
 
-      return {
-        config: config,
+      let output = {
+        config,
         files: [{filePath: configFile}],
       };
+
+      configCache.set(String(parse) + configFile, output);
+      return output;
     } catch (err) {
       if (err.code === 'MODULE_NOT_FOUND' || err.code === 'ENOENT') {
-        existsCache.delete(configFile);
         return null;
       }
 
@@ -92,3 +142,18 @@ export async function loadConfig(
 
   return null;
 }
+
+loadConfig.clear = () => {
+  configCache.reset();
+  resolveCache.clear();
+};
+
+function getParser(extname) {
+  switch (extname) {
+    case 'toml':
+      return toml;
+    case 'json':
+    default:
+      return json5;
+  }
+}

package/src/countLines.js

@@ -1,8 +1,11 @@
 // @flow strict-local
 
-export default function countLines(string: string): number {
+export default function countLines(
+  string: string,
+  startIndex: number = 0,
+): number {
   let lines = 1;
-  for (let i = 0; i < string.length; i++) {
+  for (let i = startIndex; i < string.length; i++) {
     if (string.charAt(i) === '\n') {
       lines++;
     }

package/src/debounce.js

@@ -6,7 +6,7 @@ export default function debounce<TArgs: Array<mixed>>(
 ): (...args: TArgs) => void {
   let timeout;
 
-  return function(...args: TArgs) {
+  return function (...args: TArgs) {
     if (timeout) {
       clearTimeout(timeout);
     }

package/src/dependency-location.js

@@ -1,17 +1,22 @@
 // @flow
+
 export default function createDependencyLocation(
-  start: {|
+  start: interface {
     line: number,
     column: number,
-  |},
-  moduleSpecifier: string,
+  },
+  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|},
+|} {
   return {
-    filePath: moduleSpecifier,
+    filePath: specifier,
     start: {
       line: start.line + lineOffset,
       column: start.column + columnOffset,
@@ -20,7 +25,7 @@ export default function createDependencyLocation(
       line: start.line + lineOffset,
       column:
         start.column +
-        moduleSpecifier.length -
+        specifier.length -
         1 +
         importWrapperLength +
         columnOffset,

package/src/generateBuildMetrics.js

@@ -0,0 +1,158 @@
+// @flow
+
+import type {FilePath, PackagedBundle} from '@parcel/types';
+import type {FileSystem} from '@parcel/fs';
+import SourceMap from '@parcel/source-map';
+import nullthrows from 'nullthrows';
+import path from 'path';
+import {loadSourceMapUrl} from './';
+
+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 BuildMetrics = {|
+  bundles: Array<BundleStats>,
+|};
+
+async function getSourcemapSizes(
+  filePath: FilePath,
+  fs: FileSystem,
+  projectRoot: FilePath,
+): Promise<?Map<string, number>> {
+  let bundleContents = await fs.readFile(filePath, 'utf-8');
+  let mapUrlData = await loadSourceMapUrl(fs, filePath, bundleContents);
+  if (!mapUrlData) {
+    return null;
+  }
+
+  let rawMap = mapUrlData.map;
+  let sourceMap = new SourceMap(projectRoot);
+  sourceMap.addVLQMap(rawMap);
+  let parsedMapData = sourceMap.getMap();
+
+  if (parsedMapData.mappings.length > 2) {
+    let sources = parsedMapData.sources.map(s =>
+      path.normalize(path.join(projectRoot, s)),
+    );
+    let currLine = 1;
+    let currColumn = 0;
+    let currMappingIndex = 0;
+    let currMapping = parsedMapData.mappings[currMappingIndex];
+    let nextMapping = parsedMapData.mappings[currMappingIndex + 1];
+    let sourceSizes = new Array(sources.length).fill(0);
+    let unknownOrigin: number = 0;
+    for (let i = 0; i < bundleContents.length; i++) {
+      let character = bundleContents[i];
+
+      while (
+        nextMapping &&
+        nextMapping.generated.line === currLine &&
+        nextMapping.generated.column <= currColumn
+      ) {
+        currMappingIndex++;
+        currMapping = parsedMapData.mappings[currMappingIndex];
+        nextMapping = parsedMapData.mappings[currMappingIndex + 1];
+      }
+
+      let currentSource = currMapping.source;
+      let charSize = Buffer.byteLength(character, 'utf8');
+      if (
+        currentSource != null &&
+        currMapping.generated.line === currLine &&
+        currMapping.generated.column <= currColumn
+      ) {
+        sourceSizes[currentSource] += charSize;
+      } else {
+        unknownOrigin += charSize;
+      }
+
+      if (character === '\n') {
+        currColumn = 0;
+        currLine++;
+      } else {
+        currColumn++;
+      }
+    }
+
+    let sizeMap = new Map();
+    for (let i = 0; i < sourceSizes.length; i++) {
+      sizeMap.set(sources[i], sourceSizes[i]);
+    }
+
+    sizeMap.set('', unknownOrigin);
+
+    return sizeMap;
+  }
+}
+
+async function createBundleStats(
+  bundle: PackagedBundle,
+  fs: FileSystem,
+  projectRoot: FilePath,
+) {
+  let filePath = bundle.filePath;
+  let sourcemapSizes = await getSourcemapSizes(filePath, fs, projectRoot);
+
+  let assets: Map<string, AssetStats> = new Map();
+  bundle.traverseAssets(asset => {
+    let filePath = path.normalize(asset.filePath);
+    assets.set(filePath, {
+      filePath,
+      size: asset.stats.size,
+      originalSize: asset.stats.size,
+      time: asset.stats.time,
+    });
+  });
+
+  let assetsReport: Array<AssetStats> = [];
+  if (sourcemapSizes && sourcemapSizes.size) {
+    assetsReport = Array.from(sourcemapSizes.keys()).map((filePath: string) => {
+      let foundSize = sourcemapSizes.get(filePath) || 0;
+      let stats = assets.get(filePath) || {
+        filePath,
+        size: foundSize,
+        originalSize: foundSize,
+        time: 0,
+      };
+
+      return {
+        ...stats,
+        size: foundSize,
+      };
+    });
+  } else {
+    assetsReport = Array.from(assets.values());
+  }
+
+  return {
+    filePath: nullthrows(bundle.filePath),
+    size: bundle.stats.size,
+    time: bundle.stats.time,
+    assets: assetsReport.sort((a, b) => b.size - a.size),
+  };
+}
+
+export default async function generateBuildMetrics(
+  bundles: Array<PackagedBundle>,
+  fs: FileSystem,
+  projectRoot: FilePath,
+): Promise<BuildMetrics> {
+  bundles.sort((a, b) => b.stats.size - a.stats.size).filter(b => !!b.filePath);
+
+  return {
+    bundles: (
+      await Promise.all(bundles.map(b => createBundleStats(b, fs, projectRoot)))
+    ).filter(e => !!e),
+  };
+}

package/src/generateCertificate.js

@@ -8,7 +8,7 @@ export default async function generateCertificate(
   fs: FileSystem,
   cacheDir: string,
   host: ?string,
-) {
+): Promise<{|cert: Buffer, key: Buffer|}> {
   let certDirectory = cacheDir;
 
   const privateKeyPath = path.join(certDirectory, 'private.pem');

package/src/getCertificate.js

@@ -5,7 +5,7 @@ import type {FileSystem} from '@parcel/fs';
 export default async function getCertificate(
   fs: FileSystem,
   options: HTTPSOptions,
-) {
+): Promise<{|cert: Buffer, key: Buffer|}> {
   try {
     let cert = await fs.readFile(options.cert);
     let key = await fs.readFile(options.key);

package/src/getExisting.js

@@ -14,10 +14,7 @@ export default function getExisting(
   return {
     source,
     minified: fs.existsSync(minifiedPath)
-      ? fs
-          .readFileSync(minifiedPath, 'utf8')
-          .trim()
-          .replace(/;$/, '')
+      ? fs.readFileSync(minifiedPath, 'utf8').trim().replace(/;$/, '')
       : source,
   };
 }

package/src/getRootDir.js

@@ -2,8 +2,7 @@
 
 import type {FilePath} from '@parcel/types';
 import {isGlob} from './glob';
-
-const path = require('path');
+import path from 'path';
 
 export default function getRootDir(files: Array<FilePath>): FilePath {
   let cur = null;