@parcel/utils 2.0.0-beta.3 → 2.0.0-dev.1510

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parcel/utils",
-  "version": "2.0.0-beta.3",
+  "version": "2.0.0-dev.1510+a9bb85adf",
   "description": "Blazing fast, zero configuration web application bundler",
   "license": "MIT",
   "publishConfig": {
@@ -19,30 +19,53 @@
   "engines": {
     "node": ">= 12.0.0"
   },
+  "targets": {
+    "main": {
+      "includeNodeModules": {
+        "@parcel/codeframe": false,
+        "@parcel/diagnostic": false,
+        "@parcel/rust": false,
+        "@parcel/logger": false,
+        "@parcel/markdown-ansi": false,
+        "@parcel/source-map": false,
+        "chalk": false
+      }
+    }
+  },
   "dependencies": {
-    "@iarna/toml": "^2.2.0",
-    "@parcel/codeframe": "2.0.0-beta.3",
-    "@parcel/diagnostic": "2.0.0-beta.3",
-    "@parcel/logger": "2.0.0-beta.3",
-    "@parcel/markdown-ansi": "2.0.0-beta.3",
-    "@parcel/source-map": "2.0.0-rc.1.0",
-    "ansi-html": "^0.0.7",
+    "@parcel/codeframe": "2.0.0-dev.1510+a9bb85adf",
+    "@parcel/diagnostic": "2.0.0-dev.1510+a9bb85adf",
+    "@parcel/logger": "2.0.0-dev.1510+a9bb85adf",
+    "@parcel/markdown-ansi": "2.0.0-dev.1510+a9bb85adf",
+    "@parcel/rust": "2.11.1-dev.3133+a9bb85adf",
+    "@parcel/source-map": "^2.1.1",
     "chalk": "^4.1.0",
+    "nullthrows": "^1.1.1"
+  },
+  "devDependencies": {
+    "@iarna/toml": "^2.2.0",
+    "ansi-html-community": "0.0.8",
     "clone": "^2.1.1",
-    "fast-glob": "3.1.1",
-    "fastest-levenshtein": "^1.0.8",
+    "fast-glob": "^3.2.12",
+    "fastest-levenshtein": "^1.0.16",
     "is-glob": "^4.0.0",
     "is-url": "^1.2.2",
-    "json5": "^1.0.1",
+    "json5": "^2.2.0",
     "lru-cache": "^6.0.0",
-    "micromatch": "^4.0.2",
-    "node-forge": "^0.10.0",
+    "micromatch": "^4.0.4",
+    "node-forge": "^1.2.1",
     "nullthrows": "^1.1.1",
-    "open": "^7.0.3"
+    "open": "^7.0.3",
+    "random-int": "^1.0.0",
+    "snarkdown": "^2.0.0",
+    "strip-ansi": "^6.0.0",
+    "terminal-link": "^2.1.1"
   },
-  "devDependencies": {
-    "@babel/plugin-transform-flow-strip-types": "^7.2.0",
-    "random-int": "^1.0.0"
+  "browser": {
+    "./src/generateCertificate.js": false,
+    "./src/http-server.js": false,
+    "./src/openInBrowser.js": false,
+    "@parcel/markdown-ansi": false
   },
-  "gitHead": "bf03f018093f8c7ca4c3a544524e15065a637b3b"
+  "gitHead": "a9bb85adf8f3b38631e178b3aacaa30c78696e36"
 }

package/src/DefaultMap.js

@@ -24,7 +24,7 @@ export class DefaultMap<K, V> extends Map<K, V> {
 
 // Duplicated from DefaultMap implementation for Flow
 // Roughly mirrors https://github.com/facebook/flow/blob/2eb5a78d92c167117ba9caae070afd2b9f598599/lib/core.js#L617
-export class DefaultWeakMap<K: {...}, V> extends WeakMap<K, V> {
+export class DefaultWeakMap<K: interface {}, V> extends WeakMap<K, V> {
   _getDefault: K => V;
 
   constructor(getDefault: K => V, entries?: Iterable<[K, V]>) {

package/src/PromiseQueue.js

@@ -13,6 +13,7 @@ export default class PromiseQueue<T> {
   _error: mixed;
   _count: number = 0;
   _results: Array<T> = [];
+  _addSubscriptions: Set<() => void> = new Set();
 
   constructor(opts: PromiseQueueOpts = {maxConcurrent: Infinity}) {
     if (opts.maxConcurrent <= 0) {
@@ -43,12 +44,24 @@ export default class PromiseQueue<T> {
 
       this._queue.push(wrapped);
 
+      for (const addFn of this._addSubscriptions) {
+        addFn();
+      }
+
       if (this._numRunning > 0 && this._numRunning < this._maxConcurrent) {
         this._next();
       }
     });
   }
 
+  subscribeToAdd(fn: () => void): () => void {
+    this._addSubscriptions.add(fn);
+
+    return () => {
+      this._addSubscriptions.delete(fn);
+    };
+  }
+
   run(): Promise<Array<T>> {
     if (this._runPromise != null) {
       return this._runPromise;

package/src/alternatives.js

@@ -42,6 +42,8 @@ export async function findAlternativeNodeModules(
               potentialModules.push(...orgDirContent.map(i => `${item}/${i}`));
             }),
           );
+        } else {
+          potentialModules.push(...modules);
         }
       }
     } catch (err) {
@@ -62,6 +64,8 @@ async function findAllFilesUp({
   basedir,
   maxlength,
   collected,
+  leadingDotSlash = true,
+  includeDirectories = true,
 }: {|
   fs: FileSystem,
   dir: string,
@@ -69,16 +73,18 @@ async function findAllFilesUp({
   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);
+      let relativeFilePath = relativePath(basedir, fullPath, leadingDotSlash);
       if (relativeFilePath.length < maxlength) {
         let stats = await fs.stat(fullPath);
         let isDir = stats.isDirectory();
-        if (isDir || stats.isFile()) {
+        if ((isDir && includeDirectories) || stats.isFile()) {
           collected.push(relativeFilePath);
         }
 
@@ -103,6 +109,9 @@ export async function findAlternativeFiles(
   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
@@ -112,11 +121,8 @@ export async function findAlternativeFiles(
     ['package.json'],
     projectRoot,
   );
-  if (!pkg) {
-    return potentialFiles;
-  }
 
-  let pkgRoot = path.dirname(pkg);
+  let pkgRoot = pkg ? path.dirname(pkg) : projectRoot;
   await findAllFilesUp({
     fs,
     dir: pkgRoot,
@@ -124,7 +130,16 @@ export async function findAlternativeFiles(
     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 strict-local
-import ansiHTML from 'ansi-html';
+import ansiHTML from 'ansi-html-community';
 import {escapeHTML} from './escape-html';
 
 export function ansiHtml(ansi: string): string {

package/src/blob.js

@@ -2,6 +2,7 @@
 
 import type {Blob} from '@parcel/types';
 
+import {Buffer} from 'buffer';
 import {bufferStream} from './';
 import {Readable} from 'stream';
 

package/src/collection.js

@@ -6,14 +6,14 @@ export function unique<T>(array: Array<T>): Array<T> {
 
 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++) {
@@ -34,12 +34,44 @@ function sortEntry(entry: mixed) {
   return entry;
 }
 
-export function setDifference<T>(a: Set<T>, b: Set<T>): Set<T> {
+export function setDifference<T>(
+  a: $ReadOnlySet<T>,
+  b: $ReadOnlySet<T>,
+): Set<T> {
   let difference = new Set();
   for (let e of a) {
     if (!b.has(e)) {
       difference.add(e);
     }
   }
+  for (let d of b) {
+    if (!a.has(d)) {
+      difference.add(d);
+    }
+  }
   return difference;
 }
+
+export function setIntersect<T>(a: Set<T>, b: $ReadOnlySet<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]);
+}
+
+export function setEqual<T>(a: $ReadOnlySet<T>, b: $ReadOnlySet<T>): boolean {
+  if (a.size != b.size) {
+    return false;
+  }
+  for (let entry of a) {
+    if (!b.has(entry)) {
+      return false;
+    }
+  }
+  return true;
+}

package/src/config.js

@@ -2,9 +2,10 @@
 
 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 json5 from 'json5';
 import {parse as toml} from '@iarna/toml';
 import LRU from 'lru-cache';
 
@@ -15,6 +16,7 @@ export type ConfigOutput = {|
 
 export type ConfigOptions = {|
   parse?: boolean,
+  parser?: string => any,
 |};
 
 const configCache = new LRU<FilePath, ConfigOutput>({max: 500});
@@ -69,10 +71,10 @@ export async function loadConfig(
 
     try {
       let extname = path.extname(configFile).slice(1);
-      if (extname === 'js') {
+      if (extname === 'js' || extname === 'cjs') {
         let output = {
           // $FlowFixMe
-          config: clone(require(configFile)),
+          config: clone(module.require(configFile)),
           files: [{filePath: configFile}],
         };
 
@@ -80,24 +82,7 @@ export async function loadConfig(
         return output;
       }
 
-      let configContent = await fs.readFile(configFile, 'utf8');
-      if (!configContent) return null;
-
-      let config;
-      if (parse === false) {
-        config = configContent;
-      } else {
-        let parse = getParser(extname);
-        config = parse(configContent);
-      }
-
-      let output = {
-        config,
-        files: [{filePath: configFile}],
-      };
-
-      configCache.set(String(parse) + configFile, output);
-      return output;
+      return readConfig(fs, configFile, opts);
     } catch (err) {
       if (err.code === 'MODULE_NOT_FOUND' || err.code === 'ENOENT') {
         return null;
@@ -115,12 +100,82 @@ loadConfig.clear = () => {
   resolveCache.clear();
 };
 
+export async function readConfig(
+  fs: FileSystem,
+  configFile: FilePath,
+  opts: ?ConfigOptions,
+): Promise<ConfigOutput | null> {
+  let parse = opts?.parse ?? true;
+  let cachedOutput = configCache.get(String(parse) + configFile);
+  if (cachedOutput) {
+    return cachedOutput;
+  }
+
+  try {
+    let configContent = await fs.readFile(configFile, 'utf8');
+    let config;
+    if (parse === false) {
+      config = configContent;
+    } else {
+      let extname = path.extname(configFile).slice(1);
+      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,
+                  },
+                ],
+              },
+            ],
+          },
+        });
+      }
+    }
+
+    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') {
+      return null;
+    }
+
+    throw err;
+  }
+}
+
 function getParser(extname) {
   switch (extname) {
     case 'toml':
       return toml;
     case 'json':
     default:
-      return json5;
+      return json5.parse;
   }
 }

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

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/getModuleParts.js

@@ -0,0 +1,23 @@
+// @flow strict-local
+import path from 'path';
+
+import {normalizeSeparators} from './path';
+
+/**
+ * Returns the package name and the optional subpath
+ */
+export default function getModuleParts(_name: string): [string, ?string] {
+  let name = path.normalize(_name);
+  let splitOn = name.indexOf(path.sep);
+  if (name.charAt(0) === '@') {
+    splitOn = name.indexOf(path.sep, splitOn + 1);
+  }
+  if (splitOn < 0) {
+    return [normalizeSeparators(name), undefined];
+  } else {
+    return [
+      normalizeSeparators(name.substring(0, splitOn)),
+      name.substring(splitOn + 1) || undefined,
+    ];
+  }
+}

package/src/glob.js

@@ -5,15 +5,38 @@ import type {FileSystem} from '@parcel/fs';
 
 import _isGlob from 'is-glob';
 import fastGlob, {type FastGlobOptions} from 'fast-glob';
-import {isMatch} from 'micromatch';
+import micromatch, {isMatch, makeRe, type Options} from 'micromatch';
 import {normalizeSeparators} from './path';
 
 export function isGlob(p: FilePath): any {
   return _isGlob(normalizeSeparators(p));
 }
 
-export function isGlobMatch(filePath: FilePath, glob: Glob): any {
-  return isMatch(filePath, normalizeSeparators(glob));
+export function isGlobMatch(
+  filePath: FilePath,
+  glob: Glob | Array<Glob>,
+  opts?: Options,
+): any {
+  glob = Array.isArray(glob)
+    ? glob.map(normalizeSeparators)
+    : normalizeSeparators(glob);
+  return isMatch(filePath, glob, opts);
+}
+
+export function globMatch(
+  values: Array<string>,
+  glob: Glob | Array<Glob>,
+  opts?: Options,
+): Array<string> {
+  glob = Array.isArray(glob)
+    ? glob.map(normalizeSeparators)
+    : normalizeSeparators(glob);
+
+  return micromatch(values, glob, opts);
+}
+
+export function globToRegex(glob: Glob, opts?: Options): RegExp {
+  return makeRe(glob, opts);
 }
 
 export function globSync(

package/src/hash.js

@@ -0,0 +1,49 @@
+// @flow strict-local
+
+import type {Readable} from 'stream';
+import type {FileSystem} from '@parcel/fs';
+
+import {objectSortedEntriesDeep} from './collection';
+import {hashString, Hash} from '@parcel/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 => {
+        reject(err);
+      });
+  });
+}
+
+export function hashObject(obj: {+[string]: mixed, ...}): string {
+  return hashString(JSON.stringify(objectSortedEntriesDeep(obj)));
+}
+
+let testCache: {|[string]: Promise<string>|} = {
+  /*:: ...null */
+};
+export function hashFile(fs: FileSystem, filePath: string): Promise<string> {
+  if (process.env.PARCEL_BUILD_ENV === 'test') {
+    // Development builds of these native modules are especially big and slow to hash.
+    if (
+      /parcel-swc\.[^\\/]+\.node$|lightningcss.[^\\/]+.node$/.test(filePath)
+    ) {
+      let cacheEntry = testCache[filePath];
+      if (cacheEntry) return cacheEntry;
+      let v = hashStream(fs.createReadStream(filePath));
+      testCache[filePath] = v;
+      return v;
+    }
+  }
+  return hashStream(fs.createReadStream(filePath));
+}

package/src/http-server.js

@@ -1,7 +1,15 @@
 // @flow strict-local
 
-import type {Server as HTTPOnlyServer} from 'http';
-import type {Server as HTTPSServer} from 'https';
+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 {Socket} from 'net';
 import type {FilePath, HTTPSOptions} from '@parcel/types';
 import type {FileSystem} from '@parcel/fs';
@@ -12,12 +20,16 @@ import nullthrows from 'nullthrows';
 import {getCertificate, generateCertificate} from './';
 
 type CreateHTTPServerOpts = {|
-  https: ?(HTTPSOptions | boolean),
-  inputFS: FileSystem,
-  outputFS: FileSystem,
-  cacheDir: FilePath,
-  listener?: (mixed, mixed) => void,
+  listener?: (HTTPRequest | HTTPSRequest, HTTPResponse | HTTPSResponse) => void,
   host?: string,
+  ...
+    | {|
+        https: ?(HTTPSOptions | boolean),
+        inputFS: FileSystem,
+        outputFS: FileSystem,
+        cacheDir: FilePath,
+      |}
+    | {||},
 |};
 
 export type HTTPServer = HTTPOnlyServer | HTTPSServer;