@atlaspack/utils 2.14.5-canary.21 → 2.14.5-canary.211

package/lib/debug-tools.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.debugTools = void 0;
+/*
+ * These tools are intended for Atlaspack developers, to provide extra utilities
+ * to make debugging Atlaspack issues more straightforward.
+ *
+ * To enable a tool, set the `ATLASPACK_DEBUG_TOOLS` environment variable to a
+ * comma-separated list of tool names. For example:
+ * `ATLASPACK_DEBUG_TOOLS="asset-file-names-in-output,simple-cli-reporter"`
+ *
+ * You can enable all tools by setting `ATLASPACK_DEBUG_TOOLS=all`.
+ */
+
+let debugTools = exports.debugTools = {
+  'asset-file-names-in-output': false,
+  'simple-cli-reporter': false,
+  'bundle-stats': false
+};
+const envVarValue = process.env.ATLASPACK_DEBUG_TOOLS ?? '';
+for (let tool of envVarValue.split(',')) {
+  tool = tool.trim();
+  if (tool === 'all') {
+    for (let key in debugTools) {
+      debugTools[key] = true;
+    }
+    break;
+  } else if (debugTools.hasOwnProperty(tool)) {
+    debugTools[tool] = true;
+  } else if (tool === '') {
+    continue;
+  } else {
+    // eslint-disable-next-line no-console
+    console.warn(`Unknown debug tool option: ${tool}. Valid options are: ${Object.keys(debugTools).join(', ')}`);
+  }
+}

package/lib/dependency-location.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = createDependencyLocation;
+function createDependencyLocation(start, specifier, lineOffset = 0, columnOffset = 0,
+// Imports are usually wrapped in quotes
+importWrapperLength = 2) {
+  return {
+    filePath: specifier,
+    start: {
+      line: start.line + lineOffset,
+      column: start.column + columnOffset
+    },
+    end: {
+      line: start.line + lineOffset,
+      column: start.column + specifier.length - 1 + importWrapperLength + columnOffset
+    }
+  };
+}

package/lib/escape-html.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.escapeHTML = escapeHTML;
+// Based on _.escape https://github.com/lodash/lodash/blob/master/escape.js
+const reUnescapedHtml = /[&<>"']/g;
+const reHasUnescapedHtml = RegExp(reUnescapedHtml.source);
+const htmlEscapes = {
+  '&': '&amp;',
+  '<': '&lt;',
+  '>': '&gt;',
+  '"': '&quot;',
+  "'": '&#39;'
+};
+function escapeHTML(s) {
+  if (reHasUnescapedHtml.test(s)) {
+    return s.replace(reUnescapedHtml, c => htmlEscapes[c]);
+  }
+  return s;
+}

package/lib/generateBuildMetrics.js

@@ -0,0 +1,121 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = generateBuildMetrics;
+function _sourceMap() {
+  const data = _interopRequireDefault(require("@parcel/source-map"));
+  _sourceMap = function () {
+    return data;
+  };
+  return data;
+}
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+var _ = require("./");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+async function getSourcemapSizes(filePath, fs, projectRoot) {
+  let bundleContents = await fs.readFile(filePath, 'utf-8');
+  let mapUrlData = await (0, _.loadSourceMapUrl)(fs, filePath, bundleContents);
+  if (!mapUrlData) {
+    return null;
+  }
+  let rawMap = mapUrlData.map;
+  let sourceMap = new (_sourceMap().default)(projectRoot);
+  sourceMap.addVLQMap(rawMap);
+  let parsedMapData = sourceMap.getMap();
+  if (parsedMapData.mappings.length > 2) {
+    let sources = parsedMapData.sources.map(s => _path().default.normalize(_path().default.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 = 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, fs, projectRoot) {
+  let filePath = bundle.filePath;
+  let sourcemapSizes = await getSourcemapSizes(filePath, fs, projectRoot);
+  let assets = new Map();
+  bundle.traverseAssets(asset => {
+    let filePath = _path().default.normalize(asset.filePath);
+    assets.set(filePath, {
+      filePath,
+      size: asset.stats.size,
+      originalSize: asset.stats.size,
+      time: asset.stats.time
+    });
+  });
+  let assetsReport = [];
+  if (sourcemapSizes && sourcemapSizes.size) {
+    assetsReport = Array.from(sourcemapSizes.keys()).map(filePath => {
+      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: (0, _nullthrows().default)(bundle.filePath),
+    size: bundle.stats.size,
+    time: bundle.stats.time,
+    assets: assetsReport.sort((a, b) => b.size - a.size)
+  };
+}
+async function generateBuildMetrics(bundles, fs, projectRoot) {
+  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/lib/generateCertificate.js

@@ -0,0 +1,129 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = generateCertificate;
+function _nodeForge() {
+  const data = _interopRequireDefault(require("node-forge"));
+  _nodeForge = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _logger() {
+  const data = _interopRequireDefault(require("@atlaspack/logger"));
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+async function generateCertificate(fs, cacheDir, host) {
+  let certDirectory = cacheDir;
+  const privateKeyPath = _path().default.join(certDirectory, 'private.pem');
+  const certPath = _path().default.join(certDirectory, 'primary.crt');
+  const cachedKey = (await fs.exists(privateKeyPath)) && (await fs.readFile(privateKeyPath));
+  const cachedCert = (await fs.exists(certPath)) && (await fs.readFile(certPath));
+  if (cachedKey && cachedCert) {
+    return {
+      key: cachedKey,
+      cert: cachedCert
+    };
+  }
+  _logger().default.progress('Generating SSL Certificate...');
+  const pki = _nodeForge().default.pki;
+  const keys = pki.rsa.generateKeyPair(2048);
+  const cert = pki.createCertificate();
+  cert.publicKey = keys.publicKey;
+  cert.serialNumber = Date.now().toString();
+  cert.validity.notBefore = new Date();
+  cert.validity.notAfter = new Date();
+  cert.validity.notAfter.setFullYear(cert.validity.notBefore.getFullYear() + 1);
+  const attrs = [{
+    name: 'commonName',
+    value: 'parceljs.org'
+  }, {
+    name: 'countryName',
+    value: 'US'
+  }, {
+    shortName: 'ST',
+    value: 'Virginia'
+  }, {
+    name: 'localityName',
+    value: 'Blacksburg'
+  }, {
+    name: 'organizationName',
+    value: 'parcelBundler'
+  }, {
+    shortName: 'OU',
+    value: 'Test'
+  }];
+  let altNames = [{
+    type: 2,
+    // DNS
+    value: 'localhost'
+  }, {
+    type: 7,
+    // IP
+    ip: '127.0.0.1'
+  }];
+  if (host) {
+    altNames.push({
+      type: 2,
+      // DNS
+      value: host
+    });
+  }
+  cert.setSubject(attrs);
+  cert.setIssuer(attrs);
+  cert.setExtensions([{
+    name: 'basicConstraints',
+    cA: false
+  }, {
+    name: 'keyUsage',
+    keyCertSign: true,
+    digitalSignature: true,
+    nonRepudiation: true,
+    keyEncipherment: true,
+    dataEncipherment: true
+  }, {
+    name: 'extKeyUsage',
+    serverAuth: true,
+    clientAuth: true,
+    codeSigning: true,
+    emailProtection: true,
+    timeStamping: true
+  }, {
+    name: 'nsCertType',
+    client: true,
+    server: true,
+    email: true,
+    objsign: true,
+    sslCA: true,
+    emailCA: true,
+    objCA: true
+  }, {
+    name: 'subjectAltName',
+    altNames
+  }, {
+    name: 'subjectKeyIdentifier'
+  }]);
+  cert.sign(keys.privateKey, _nodeForge().default.md.sha256.create());
+  const privPem = pki.privateKeyToPem(keys.privateKey);
+  const certPem = pki.certificateToPem(cert);
+  await fs.mkdirp(certDirectory);
+  await fs.writeFile(privateKeyPath, privPem);
+  await fs.writeFile(certPath, certPem);
+  return {
+    key: privPem,
+    cert: certPem
+  };
+}

package/lib/getCertificate.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = getCertificate;
+async function getCertificate(fs, options) {
+  try {
+    let cert = await fs.readFile(options.cert);
+    let key = await fs.readFile(options.key);
+    return {
+      key,
+      cert
+    };
+  } catch (err) {
+    throw new Error('Certificate and/or key not found');
+  }
+}

package/lib/getExisting.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = getExisting;
+function _fs() {
+  const data = _interopRequireDefault(require("fs"));
+  _fs = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Creates an object that contains both source and minified (using the source as a fallback).
+ * e.g. builtins.min.js and builtins.js.
+ */
+function getExisting(minifiedPath, sourcePath) {
+  let source = _fs().default.readFileSync(sourcePath, 'utf8').trim();
+  return {
+    source,
+    minified: _fs().default.existsSync(minifiedPath) ? _fs().default.readFileSync(minifiedPath, 'utf8').trim().replace(/;$/, '') : source
+  };
+}

package/lib/getModuleParts.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = getModuleParts;
+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 }; }
+/**
+ * Returns the package name and the optional subpath
+ */
+function getModuleParts(_name) {
+  let name = _path().default.normalize(_name);
+  let splitOn = name.indexOf(_path().default.sep);
+  if (name.charAt(0) === '@') {
+    splitOn = name.indexOf(_path().default.sep, splitOn + 1);
+  }
+  if (splitOn < 0) {
+    return [(0, _path2.normalizeSeparators)(name), undefined];
+  } else {
+    return [(0, _path2.normalizeSeparators)(name.substring(0, splitOn)), name.substring(splitOn + 1) || undefined];
+  }
+}

package/lib/getRootDir.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = getRootDir;
+var _glob = require("./glob");
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function getRootDir(files) {
+  let cur = null;
+  for (let file of files) {
+    let parsed = _path().default.parse(file);
+    parsed.dir = findGlobRoot(parsed.dir);
+    if (!cur) {
+      cur = parsed;
+    } else if (parsed.root !== cur.root) {
+      // bail out. there is no common root.
+      // this can happen on windows, e.g. C:\foo\bar vs. D:\foo\bar
+      return process.cwd();
+    } else {
+      // find the common path parts.
+      let curParts = cur.dir.split(_path().default.sep);
+      let newParts = parsed.dir.split(_path().default.sep);
+      let len = Math.min(curParts.length, newParts.length);
+      let i = 0;
+      while (i < len && curParts[i] === newParts[i]) {
+        i++;
+      }
+      cur.dir = i > 1 ? curParts.slice(0, i).join(_path().default.sep) : cur.root;
+    }
+  }
+  return cur ? cur.dir : process.cwd();
+}
+
+// Transforms a path like `packages/*/src/index.js` to the root of the glob, `packages/`
+function findGlobRoot(dir) {
+  let parts = dir.split(_path().default.sep);
+  let last = parts.length;
+  for (let i = parts.length - 1; i >= 0; i--) {
+    if ((0, _glob.isGlob)(parts[i])) {
+      last = i;
+    }
+  }
+  return parts.slice(0, last).join(_path().default.sep);
+}

package/lib/glob.js

@@ -0,0 +1,110 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.glob = glob;
+exports.globMatch = globMatch;
+exports.globSync = globSync;
+exports.globToRegex = globToRegex;
+exports.isGlob = isGlob;
+exports.isGlobMatch = isGlobMatch;
+function _isGlob2() {
+  const data = _interopRequireDefault(require("is-glob"));
+  _isGlob2 = function () {
+    return data;
+  };
+  return data;
+}
+function _fastGlob() {
+  const data = _interopRequireDefault(require("fast-glob"));
+  _fastGlob = function () {
+    return data;
+  };
+  return data;
+}
+function _micromatch() {
+  const data = _interopRequireWildcard(require("micromatch"));
+  _micromatch = function () {
+    return data;
+  };
+  return data;
+}
+var _path = require("./path");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function isGlob(p) {
+  return (0, _isGlob2().default)((0, _path.normalizeSeparators)(p));
+}
+function isGlobMatch(filePath, glob, opts) {
+  glob = Array.isArray(glob) ? glob.map(_path.normalizeSeparators) : (0, _path.normalizeSeparators)(glob);
+  return (0, _micromatch().isMatch)(filePath, glob, opts);
+}
+function globMatch(values, glob, opts) {
+  glob = Array.isArray(glob) ? glob.map(_path.normalizeSeparators) : (0, _path.normalizeSeparators)(glob);
+  return (0, _micromatch().default)(values, glob, opts);
+}
+function globToRegex(glob, opts) {
+  return (0, _micromatch().makeRe)(glob, opts);
+}
+function globSync(p, fs, options) {
+  options = {
+    ...options,
+    fs: {
+      statSync: p => {
+        return fs.statSync(p);
+      },
+      lstatSync: p => {
+        // Our FileSystem interface doesn't have lstat support at the moment,
+        // but this is fine for our purposes since we follow symlinks by default.
+        return fs.statSync(p);
+      },
+      // @ts-expect-error TS7006
+      readdirSync: (p, opts) => {
+        return fs.readdirSync(p, opts);
+      }
+    }
+  };
+  return _fastGlob().default.sync((0, _path.normalizeSeparators)(p), options);
+}
+function glob(p, fs, options) {
+  options = {
+    ...options,
+    fs: {
+      stat: async (p, cb) => {
+        try {
+          cb(null, await fs.stat(p));
+        } catch (err) {
+          // @ts-expect-error TS2345
+          cb(err);
+        }
+      },
+      lstat: async (p, cb) => {
+        // Our FileSystem interface doesn't have lstat support at the moment,
+        // but this is fine for our purposes since we follow symlinks by default.
+        try {
+          cb(null, await fs.stat(p));
+        } catch (err) {
+          // @ts-expect-error TS2345
+          cb(err);
+        }
+      },
+      // @ts-expect-error TS7006
+      readdir: async (p, opts, cb) => {
+        if (typeof opts === 'function') {
+          cb = opts;
+          // @ts-expect-error TS2322
+          opts = null;
+        }
+        try {
+          cb(null, await fs.readdir(p, opts));
+        } catch (err) {
+          // @ts-expect-error TS2345
+          cb(err);
+        }
+      }
+    }
+  };
+  return (0, _fastGlob().default)((0, _path.normalizeSeparators)(p), options);
+}

package/lib/hash.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hashFile = hashFile;
+exports.hashObject = hashObject;
+exports.hashStream = hashStream;
+var _collection = require("./collection");
+function _rust() {
+  const data = require("@atlaspack/rust");
+  _rust = function () {
+    return data;
+  };
+  return data;
+}
+function hashStream(stream) {
+  let hash = new (_rust().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);
+    });
+  });
+}
+function hashObject(obj) {
+  return (0, _rust().hashString)(JSON.stringify((0, _collection.objectSortedEntriesDeep)(obj)));
+}
+let testCache = {
+  /*:: ...null */
+};
+function hashFile(fs, filePath) {
+  if (process.env.ATLASPACK_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));
+}