@atlaspack/utils 2.14.5-canary.14 → 2.14.5-canary.140

package/lib/sourcemap.d.ts

@@ -0,0 +1,16 @@
+import type { SourceLocation } from '@atlaspack/types';
+import type { FileSystem } from '@atlaspack/fs';
+import SourceMap from '@parcel/source-map';
+export declare const SOURCEMAP_RE: RegExp;
+export declare const SOURCEMAP_EXTENSIONS: Set<string>;
+export declare function matchSourceMappingURL(contents: string): RegExpMatchArray | null;
+export declare function loadSourceMapUrl(fs: FileSystem, filename: string, contents: string): Promise<{
+    filename: string;
+    map: any;
+    url: string;
+} | null | undefined>;
+export declare function loadSourceMap(filename: string, contents: string, options: {
+    fs: FileSystem;
+    projectRoot: string;
+}): Promise<SourceMap | null | undefined>;
+export declare function remapSourceLocation(loc: SourceLocation, originalMap: SourceMap): SourceLocation;

package/lib/sourcemap.js

@@ -0,0 +1,127 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SOURCEMAP_RE = exports.SOURCEMAP_EXTENSIONS = void 0;
+exports.loadSourceMap = loadSourceMap;
+exports.loadSourceMapUrl = loadSourceMapUrl;
+exports.matchSourceMappingURL = matchSourceMappingURL;
+exports.remapSourceLocation = remapSourceLocation;
+function _sourceMap() {
+  const data = _interopRequireDefault(require("@parcel/source-map"));
+  _sourceMap = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+var _path2 = require("./path");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const SOURCEMAP_RE = exports.SOURCEMAP_RE = /(?:\/\*|\/\/)\s*[@#]\s*sourceMappingURL\s*=\s*([^\s*]+)(?:\s*\*\/)?\s*$/;
+const DATA_URL_RE = /^data:[^;]+(?:;charset=[^;]+)?;base64,(.*)/;
+const SOURCEMAP_EXTENSIONS = exports.SOURCEMAP_EXTENSIONS = new Set(['css', 'es', 'es6', 'js', 'jsx', 'mjs', 'ts', 'tsx']);
+function matchSourceMappingURL(contents) {
+  return contents.match(SOURCEMAP_RE);
+}
+async function loadSourceMapUrl(fs, filename, contents) {
+  let match = matchSourceMappingURL(contents);
+  if (match) {
+    let url = match[1].trim();
+    let dataURLMatch = url.match(DATA_URL_RE);
+    let mapFilePath;
+    if (dataURLMatch) {
+      mapFilePath = filename;
+    } else {
+      mapFilePath = url.replace(/^file:\/\//, '');
+      mapFilePath = (0, _path2.isAbsolute)(mapFilePath) ? mapFilePath : _path().default.join(_path().default.dirname(filename), mapFilePath);
+    }
+    return {
+      url,
+      filename: mapFilePath,
+      map: JSON.parse(dataURLMatch ? Buffer.from(dataURLMatch[1], 'base64').toString() : await fs.readFile(mapFilePath, 'utf8'))
+    };
+  }
+}
+async function loadSourceMap(filename, contents, options) {
+  let foundMap = await loadSourceMapUrl(options.fs, filename, contents);
+  if (foundMap) {
+    let mapSourceRoot = _path().default.dirname(filename);
+    if (foundMap.map.sourceRoot && !(0, _path2.normalizeSeparators)(foundMap.map.sourceRoot).startsWith('/')) {
+      mapSourceRoot = _path().default.join(mapSourceRoot, foundMap.map.sourceRoot);
+    }
+    let sourcemapInstance = new (_sourceMap().default)(options.projectRoot);
+    sourcemapInstance.addVLQMap({
+      ...foundMap.map,
+      sources: foundMap.map.sources.map(s => {
+        return _path().default.join(mapSourceRoot, s);
+      })
+    });
+    return sourcemapInstance;
+  }
+}
+function remapSourceLocation(loc, originalMap) {
+  let {
+    filePath,
+    start: {
+      line: startLine,
+      column: startCol
+    },
+    end: {
+      line: endLine,
+      column: endCol
+    }
+  } = loc;
+  let lineDiff = endLine - startLine;
+  let colDiff = endCol - startCol;
+  let start = originalMap.findClosestMapping(startLine, startCol - 1);
+  let end = originalMap.findClosestMapping(endLine, endCol - 1);
+  if (start !== null && start !== void 0 && start.original) {
+    if (start.source) {
+      filePath = start.source;
+    }
+    ({
+      line: startLine,
+      column: startCol
+    } = start.original);
+    startCol++; // source map columns are 0-based
+  }
+
+  if (end !== null && end !== void 0 && end.original) {
+    ({
+      line: endLine,
+      column: endCol
+    } = end.original);
+    endCol++; // source map columns are 0-based
+
+    if (endLine < startLine) {
+      endLine = startLine;
+      endCol = startCol;
+    } else if (endLine === startLine && endCol < startCol && lineDiff === 0) {
+      endCol = startCol + colDiff;
+    } else if (endLine === startLine && startCol === endCol && lineDiff === 0) {
+      // Prevent 0-length ranges
+      endCol = startCol + 1;
+    }
+  } else {
+    endLine = startLine;
+    endCol = startCol;
+  }
+  return {
+    filePath,
+    start: {
+      line: startLine,
+      column: startCol
+    },
+    end: {
+      line: endLine,
+      column: endCol
+    }
+  };
+}

package/lib/stream.d.ts

@@ -0,0 +1,8 @@
+import { Readable } from 'stream';
+import type { Blob } from '@atlaspack/types';
+export declare function measureStreamLength(stream: Readable): Promise<number>;
+export declare function readableFromStringOrBuffer(str: string | Buffer): Readable;
+export declare function bufferStream(stream: Readable): Promise<Buffer>;
+export declare function blobToStream(blob: Blob): Readable;
+export declare function streamFromPromise(promise: Promise<Blob>): Readable;
+export declare function fallbackStream(stream: Readable, fallback: () => Readable): Readable;

package/lib/stream.js

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.blobToStream = blobToStream;
+exports.bufferStream = bufferStream;
+exports.fallbackStream = fallbackStream;
+exports.measureStreamLength = measureStreamLength;
+exports.readableFromStringOrBuffer = readableFromStringOrBuffer;
+exports.streamFromPromise = streamFromPromise;
+function _stream() {
+  const data = require("stream");
+  _stream = function () {
+    return data;
+  };
+  return data;
+}
+function measureStreamLength(stream) {
+  return new Promise((resolve, reject) => {
+    let length = 0;
+    stream.on('data', chunk => {
+      length += chunk;
+    });
+    stream.on('end', () => resolve(length));
+    stream.on('error', reject);
+  });
+}
+function readableFromStringOrBuffer(str) {
+  // https://stackoverflow.com/questions/12755997/how-to-create-streams-from-string-in-node-js
+  const stream = new (_stream().Readable)();
+  stream.push(str);
+  stream.push(null);
+  return stream;
+}
+function bufferStream(stream) {
+  return new Promise((resolve, reject) => {
+    let buf = Buffer.from([]);
+    stream.on('data', data => {
+      buf = Buffer.concat([buf, data]);
+    });
+    stream.on('end', () => {
+      resolve(buf);
+    });
+    stream.on('error', reject);
+  });
+}
+function blobToStream(blob) {
+  if (blob instanceof _stream().Readable) {
+    return blob;
+  }
+  return readableFromStringOrBuffer(blob);
+}
+function streamFromPromise(promise) {
+  const stream = new (_stream().PassThrough)();
+  promise.then(blob => {
+    if (blob instanceof _stream().Readable) {
+      blob.pipe(stream);
+    } else {
+      stream.end(blob);
+    }
+  });
+  return stream;
+}
+function fallbackStream(stream, fallback) {
+  const res = new (_stream().PassThrough)();
+  stream.on('error', err => {
+    if (err.code === 'ENOENT') {
+      fallback().pipe(res);
+    } else {
+      res.emit('error', err);
+    }
+  });
+  stream.pipe(res);
+  return res;
+}

package/lib/throttle.d.ts

@@ -0,0 +1 @@
+export default function throttle<TArgs extends Array<unknown>>(fn: (...args: TArgs) => unknown, delay: number): (...args: TArgs) => void;

package/lib/throttle.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = throttle;
+function throttle(fn, delay) {
+  let lastCalled;
+  return function throttled(...args) {
+    if (lastCalled == null || lastCalled + delay <= Date.now()) {
+      fn.call(this, ...args);
+      lastCalled = Date.now();
+    }
+  };
+}

package/lib/urlJoin.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Joins a path onto a URL, and normalizes Windows paths
+ * e.g. from \path\to\res.js to /path/to/res.js.
+ */
+export default function urlJoin(publicURL: string, assetPath: string): string;

package/lib/urlJoin.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = urlJoin;
+function _url() {
+  const data = _interopRequireDefault(require("url"));
+  _url = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Joins a path onto a URL, and normalizes Windows paths
+ * e.g. from \path\to\res.js to /path/to/res.js.
+ */
+function urlJoin(publicURL, assetPath) {
+  const url = _url().default.parse(publicURL, false, true);
+  // Leading / ensures that paths with colons are not parsed as a protocol.
+  let p = assetPath.startsWith('/') ? assetPath : '/' + assetPath;
+  const assetUrl = _url().default.parse(p);
+  url.pathname = _path().default.posix.join(url.pathname ?? '', assetUrl.pathname ?? '');
+  url.search = assetUrl.search;
+  url.hash = assetUrl.hash;
+  return _url().default.format(url);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/utils",
-  "version": "2.14.5-canary.14+267b0d591",
+  "version": "2.14.5-canary.140+43fdd2238",
   "description": "Blazing fast, zero configuration web application bundler",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
@@ -10,8 +10,9 @@
     "type": "git",
     "url": "https://github.com/atlassian-labs/atlaspack.git"
   },
-  "main": "lib/index.js",
-  "source": "src/index.js",
+  "main": "./lib/index.js",
+  "source": "./src/index.ts",
+  "types": "./lib/index.d.ts",
   "engines": {
     "node": ">= 16.0.0"
   },
@@ -30,19 +31,18 @@
     }
   },
   "dependencies": {
-    "@atlaspack/codeframe": "2.13.3-canary.82+267b0d591",
-    "@atlaspack/diagnostic": "2.14.1-canary.82+267b0d591",
-    "@atlaspack/feature-flags": "2.14.1-canary.82+267b0d591",
-    "@atlaspack/logger": "2.14.5-canary.14+267b0d591",
-    "@atlaspack/markdown-ansi": "2.14.1-canary.82+267b0d591",
-    "@atlaspack/rust": "3.2.1-canary.14+267b0d591",
-    "@parcel/source-map": "^2.1.1",
-    "chalk": "^4.1.0",
-    "nullthrows": "^1.1.1"
-  },
-  "devDependencies": {
+    "@atlaspack/codeframe": "2.13.3-canary.208+43fdd2238",
+    "@atlaspack/diagnostic": "2.14.1-canary.208+43fdd2238",
+    "@atlaspack/feature-flags": "2.14.1-canary.208+43fdd2238",
+    "@atlaspack/logger": "2.14.5-canary.140+43fdd2238",
+    "@atlaspack/markdown-ansi": "2.14.1-canary.208+43fdd2238",
+    "@atlaspack/rust": "3.2.1-canary.140+43fdd2238",
     "@iarna/toml": "^2.2.0",
+    "@parcel/source-map": "^2.1.1",
+    "@types/micromatch": "^4.0.9",
+    "@types/node-forge": "^1.3.13",
     "ansi-html-community": "0.0.8",
+    "chalk": "^4.1.0",
     "clone": "^2.1.1",
     "fast-glob": "^3.2.12",
     "fastest-levenshtein": "^1.0.16",
@@ -54,11 +54,15 @@
     "node-forge": "^1.2.1",
     "nullthrows": "^1.1.1",
     "open": "^7.0.3",
-    "random-int": "^1.0.0",
     "snarkdown": "^2.0.0",
     "strip-ansi": "^6.0.0",
     "terminal-link": "^2.1.1"
   },
+  "devDependencies": {
+    "@atlaspack/babel-register": "2.14.1",
+    "benny": "^3.7.1",
+    "random-int": "^1.0.0"
+  },
   "browser": {
     "./src/generateCertificate.js": false,
     "./src/http-server.js": false,
@@ -66,5 +70,8 @@
     "@atlaspack/markdown-ansi": false
   },
   "type": "commonjs",
-  "gitHead": "267b0d59131c00e4cd1526bbf87aa84b9c8fd411"
-}
+  "scripts": {
+    "check-ts": "tsc --emitDeclarationOnly --rootDir src"
+  },
+  "gitHead": "43fdd223860fbc97af17d68c65419b97412cb888"
+}

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

@@ -1,9 +1,7 @@
-// @flow strict-local
-
 export class DefaultMap<K, V> extends Map<K, V> {
-  _getDefault: (K) => V;
+  _getDefault: (arg1: K) => V;
 
-  constructor(getDefault: (K) => V, entries?: Iterable<[K, V]>) {
+  constructor(getDefault: (arg1: K) => V, entries?: Iterable<[K, V]>) {
     super(entries);
     this._getDefault = getDefault;
   }
@@ -17,8 +15,7 @@ export class DefaultMap<K, V> extends Map<K, V> {
       this.set(key, ret);
     }
 
-    // $FlowFixMe
-    return ret;
+    return ret as V;
   }
 }
 
@@ -26,11 +23,11 @@ interface Key {}
 
 // Duplicated from DefaultMap implementation for Flow
 // Roughly mirrors https://github.com/facebook/flow/blob/2eb5a78d92c167117ba9caae070afd2b9f598599/lib/core.js#L617
-export class DefaultWeakMap<K: Key, V> extends WeakMap<K, V> {
-  _getDefault: (K) => V;
+export class DefaultWeakMap<K extends Key, V> extends WeakMap<K, V> {
+  _getDefault: (arg1: K) => V;
 
-  constructor(getDefault: (K) => V, entries?: Iterable<[K, V]>) {
-    super(entries);
+  constructor(getDefault: (arg1: K) => V, entries?: Iterable<[K, V]>) {
+    super(entries as Iterable<readonly [K, V]>);
     this._getDefault = getDefault;
   }
 
@@ -43,7 +40,6 @@ export class DefaultWeakMap<K: Key, V> extends WeakMap<K, V> {
       this.set(key, ret);
     }
 
-    // $FlowFixMe
-    return ret;
+    return ret as V;
   }
 }

package/src/Deferred.ts

@@ -0,0 +1,26 @@
+import invariant from 'assert';
+
+export type Deferred<T> = {
+  resolve(arg1: T): void;
+  reject(arg1: unknown): void;
+};
+
+export function makeDeferredWithPromise<T>(): {
+  deferred: Deferred<T>;
+  promise: Promise<T>;
+} {
+  let deferred: Deferred<T> | null | undefined;
+  let promise = new Promise<T>(
+    (
+      resolve: (result: Promise<T> | T) => void,
+      reject: (error?: any) => void,
+    ) => {
+      deferred = {resolve, reject};
+    },
+  );
+
+  // Promise constructor callback executes synchronously, so this is defined
+  invariant(deferred != null);
+
+  return {deferred, promise};
+}

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

@@ -1,16 +1,16 @@
-// @flow strict-local
-
 import {makeDeferredWithPromise, type Deferred} from './Deferred';
 
-type PromiseQueueOpts = {|maxConcurrent: number|};
+type PromiseQueueOpts = {
+  maxConcurrent: number;
+};
 
 export default class PromiseQueue<T> {
-  _deferred: ?Deferred<Array<T>>;
+  _deferred: Deferred<Array<T>> | null | undefined;
   _maxConcurrent: number;
   _numRunning: number = 0;
   _queue: Array<() => Promise<void>> = [];
-  _runPromise: ?Promise<Array<T>> = null;
-  _error: mixed;
+  _runPromise: Promise<Array<T>> | null | undefined = null;
+  _error: unknown;
   _count: number = 0;
   _results: Array<T> = [];
   _addSubscriptions: Set<() => void> = new Set();
@@ -28,30 +28,35 @@ export default class PromiseQueue<T> {
   }
 
   add(fn: () => Promise<T>): void {
-    new Promise((resolve, reject) => {
-      let i = this._count++;
-      let wrapped = () =>
-        fn().then(
-          (result) => {
-            this._results[i] = result;
-            resolve(result);
-          },
-          (err) => {
-            reject(err);
-            throw err;
-          },
-        );
-
-      this._queue.push(wrapped);
-
-      for (const addFn of this._addSubscriptions) {
-        addFn();
-      }
-
-      if (this._numRunning > 0 && this._numRunning < this._maxConcurrent) {
-        this._next();
-      }
-    }).catch(() => {});
+    new Promise(
+      (
+        resolve: (result: Promise<T> | T) => void,
+        reject: (error?: any) => void,
+      ) => {
+        let i = this._count++;
+        let wrapped = () =>
+          fn().then(
+            (result) => {
+              this._results[i] = result;
+              resolve(result);
+            },
+            (err) => {
+              reject(err);
+              throw err;
+            },
+          );
+
+        this._queue.push(wrapped);
+
+        for (const addFn of this._addSubscriptions) {
+          addFn();
+        }
+
+        if (this._numRunning > 0 && this._numRunning < this._maxConcurrent) {
+          this._next();
+        }
+      },
+    ).catch(() => {});
   }
 
   subscribeToAdd(fn: () => void): () => void {
@@ -71,9 +76,9 @@ export default class PromiseQueue<T> {
       return Promise.resolve([]);
     }
 
-    let {deferred, promise} = makeDeferredWithPromise();
+    let {deferred, promise} = makeDeferredWithPromise<Array<T>>();
     this._deferred = deferred;
-    this._runPromise = promise;
+    this._runPromise = promise as Promise<Array<T>>;
 
     while (this._queue.length && this._numRunning < this._maxConcurrent) {
       this._next();
@@ -84,7 +89,7 @@ export default class PromiseQueue<T> {
 
   async _next(): Promise<void> {
     let fn = this._queue.shift();
-    await this._runFn(fn);
+    await this._runFn(fn as () => unknown);
     if (this._queue.length) {
       this._next();
     } else if (this._numRunning === 0) {
@@ -92,11 +97,11 @@ export default class PromiseQueue<T> {
     }
   }
 
-  async _runFn(fn: () => mixed): Promise<void> {
+  async _runFn(fn: () => unknown): Promise<void> {
     this._numRunning++;
     try {
       await fn();
-    } catch (e) {
+    } catch (e: any) {
       // Only store the first error that occurs.
       // We don't reject immediately so that any other concurrent
       // requests have time to complete.

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

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import {Transform} from 'stream';
 
 /*
@@ -7,21 +5,24 @@ import {Transform} from 'stream';
  * callback. Continues to pass data chunks down the stream.
  */
 export default class TapStream extends Transform {
-  _tap: (Buffer) => mixed;
-  constructor(tap: (Buffer) => mixed, options: mixed) {
-    super({...options});
+  _tap: (arg1: Buffer) => unknown;
+  constructor(tap: (arg1: Buffer) => unknown, options: unknown) {
+    super({...(options as any)});
     this._tap = tap;
   }
 
   _transform(
     chunk: Buffer | string,
     encoding: string,
-    callback: (err: ?Error, chunk?: Buffer | string) => mixed,
+    callback: (
+      err?: Error | null | undefined,
+      chunk?: Buffer | string,
+    ) => unknown,
   ) {
     try {
       this._tap(Buffer.from(chunk));
       callback(null, chunk);
-    } catch (err) {
+    } catch (err: any) {
       callback(err);
     }
   }

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

@@ -1,4 +1,3 @@
-// @flow
 import path from 'path';
 import type {FileSystem} from '@atlaspack/types';
 import {fuzzySearch} from './schema';
@@ -48,7 +47,7 @@ export async function findAlternativeNodeModules(
           potentialModules.push(...modules);
         }
       }
-    } catch (err) {
+    } catch (err: any) {
       // ignore
     }
 
@@ -68,16 +67,16 @@ async function findAllFilesUp({
   collected,
   leadingDotSlash = true,
   includeDirectories = true,
-}: {|
-  fs: FileSystem,
-  dir: string,
-  root: string,
-  basedir: string,
-  maxlength: number,
-  collected: Array<string>,
-  leadingDotSlash?: boolean,
-  includeDirectories?: boolean,
-|}): Promise<mixed> {
+}: {
+  fs: FileSystem;
+  dir: string;
+  root: string;
+  basedir: string;
+  maxlength: number;
+  collected: Array<string>;
+  leadingDotSlash?: boolean;
+  includeDirectories?: boolean;
+}): Promise<unknown> {
   let dirContent = (await fs.readdir(dir)).sort();
   return Promise.all(
     dirContent.map(async (item) => {
@@ -111,9 +110,9 @@ export async function findAlternativeFiles(
   fileSpecifier: string,
   dir: string,
   projectRoot: string,
-  leadingDotSlash?: boolean = true,
-  includeDirectories?: boolean = true,
-  includeExtension?: boolean = false,
+  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

package/src/{ansi-html.js → ansi-html.ts}

@@ -1,4 +1,4 @@
-// @flow strict-local
+// @ts-expect-error ansi-html-community is not typed
 import ansiHTML from 'ansi-html-community';
 import {escapeHTML} from './escape-html';
 

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

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import type {Blob} from '@atlaspack/types';
 
 import {Buffer} from 'buffer';
@@ -12,7 +10,7 @@ export function blobToBuffer(blob: Blob): Promise<Buffer> {
   } else if (blob instanceof Buffer) {
     return Promise.resolve(Buffer.from(blob));
   } else {
-    return Promise.resolve(Buffer.from(blob, 'utf8'));
+    return Promise.resolve(Buffer.from(blob as string, 'utf8'));
   }
 }
 
@@ -22,6 +20,6 @@ export async function blobToString(blob: Blob): Promise<string> {
   } else if (blob instanceof Buffer) {
     return blob.toString();
   } else {
-    return blob;
+    return blob as string;
   }
 }