@atlaspack/utils 2.16.1 → 2.16.2-noselfbuild-342bd6c75.0

package/lib/collection.js

@@ -0,0 +1,111 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.objectSortedEntries = objectSortedEntries;
+exports.objectSortedEntriesDeep = objectSortedEntriesDeep;
+exports.setDifference = setDifference;
+exports.setEqual = setEqual;
+exports.setIntersect = setIntersect;
+exports.setIntersectStatic = setIntersectStatic;
+exports.setSymmetricDifference = setSymmetricDifference;
+exports.setUnion = setUnion;
+exports.unique = unique;
+function unique(array) {
+  return [...new Set(array)];
+}
+function objectSortedEntries(obj) {
+  return Object.entries(obj).sort(([keyA], [keyB]) => keyA.localeCompare(keyB));
+}
+function objectSortedEntriesDeep(object) {
+  let sortedEntries = objectSortedEntries(object);
+  for (let i = 0; i < sortedEntries.length; i++) {
+    sortedEntries[i][1] = sortEntry(sortedEntries[i][1]);
+  }
+  return sortedEntries;
+}
+function sortEntry(entry) {
+  if (Array.isArray(entry)) {
+    return entry.map(sortEntry);
+  }
+  if (typeof entry === 'object' && entry != null) {
+    return objectSortedEntriesDeep(entry);
+  }
+  return entry;
+}
+
+/**
+ * Get the difference of A and B sets
+ *
+ * This is the set of elements which are in A but not in B
+ * For example, the difference of the sets {1,2,3} and {3,4} is {1,2}
+ *
+ * @param {*} a Set A
+ * @param {*} b Set B
+ * @returns A \ B
+ */
+function setDifference(a, b) {
+  let difference = new Set();
+  for (let e of a) {
+    if (!b.has(e)) {
+      difference.add(e);
+    }
+  }
+  return difference;
+}
+
+/**
+ * Get the symmetric difference of A and B sets
+ *
+ * This is the set of elements which are in either of the sets, but not in their intersection.
+ * For example, the symmetric difference of the sets {1,2,3} and {3,4} is {1,2,4}
+ *
+ * @param {*} a Set A
+ * @param {*} b Set B
+ * @returns A Δ B
+ */
+function setSymmetricDifference(a, b) {
+  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;
+}
+function setIntersect(a, b) {
+  for (let entry of a) {
+    if (!b.has(entry)) {
+      a.delete(entry);
+    }
+  }
+}
+function setIntersectStatic(a, b) {
+  let intersection = new Set();
+  for (let entry of a) {
+    if (b.has(entry)) {
+      intersection.add(entry);
+    }
+  }
+  return intersection;
+}
+function setUnion(a, b) {
+  return new Set([...a, ...b]);
+}
+function setEqual(a, b) {
+  if (a.size != b.size) {
+    return false;
+  }
+  for (let entry of a) {
+    if (!b.has(entry)) {
+      return false;
+    }
+  }
+  return true;
+}

package/lib/config.js

@@ -0,0 +1,172 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadConfig = loadConfig;
+exports.readConfig = readConfig;
+exports.resolveConfig = resolveConfig;
+exports.resolveConfigSync = resolveConfigSync;
+function _diagnostic() {
+  const data = _interopRequireDefault(require("@atlaspack/diagnostic"));
+  _diagnostic = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _clone() {
+  const data = _interopRequireDefault(require("clone"));
+  _clone = function () {
+    return data;
+  };
+  return data;
+}
+function _json() {
+  const data = _interopRequireDefault(require("json5"));
+  _json = function () {
+    return data;
+  };
+  return data;
+}
+function _toml() {
+  const data = require("@iarna/toml");
+  _toml = function () {
+    return data;
+  };
+  return data;
+}
+function _lruCache() {
+  const data = _interopRequireDefault(require("lru-cache"));
+  _lruCache = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const configCache = new (_lruCache().default)({
+  max: 500
+});
+const resolveCache = new Map();
+function resolveConfig(fs, filepath, filenames, projectRoot) {
+  // Cache the result of resolving config for this directory.
+  // This is automatically invalidated at the end of the current build.
+  let key = _path().default.dirname(filepath) + filenames.join(',');
+  let cached = resolveCache.get(key);
+  if (cached !== undefined) {
+    return Promise.resolve(cached);
+  }
+  let resolved = fs.findAncestorFile(filenames, _path().default.dirname(filepath), projectRoot);
+  resolveCache.set(key, resolved);
+  return Promise.resolve(resolved);
+}
+function resolveConfigSync(fs, filepath, filenames, projectRoot) {
+  return fs.findAncestorFile(filenames, _path().default.dirname(filepath), projectRoot);
+}
+async function loadConfig(fs, filepath, filenames, projectRoot, opts) {
+  let parse = (opts === null || opts === void 0 ? void 0 : 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().default.extname(configFile).slice(1);
+      if (extname === 'js' || extname === 'cjs') {
+        let output = {
+          // $FlowFixMe
+          config: (0, _clone().default)(module.require(configFile)),
+          files: [{
+            filePath: configFile
+          }]
+        };
+        configCache.set(configFile, output);
+        return output;
+      }
+      return readConfig(fs, configFile, opts);
+    } catch (err) {
+      if (err.code === 'MODULE_NOT_FOUND' || err.code === 'ENOENT') {
+        return null;
+      }
+      throw err;
+    }
+  }
+  return null;
+}
+loadConfig.clear = () => {
+  configCache.reset();
+  resolveCache.clear();
+};
+async function readConfig(fs, configFile, opts) {
+  let parse = (opts === null || opts === void 0 ? void 0 : 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().default.extname(configFile).slice(1);
+      let parse = (opts === null || opts === void 0 ? void 0 : 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 (_diagnostic().default)({
+          diagnostic: {
+            message: `Failed to parse ${_path().default.basename(configFile)}`,
+            origin: '@atlaspack/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().parse;
+    case 'json':
+    default:
+      return _json().default.parse;
+  }
+}

package/lib/countLines.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = countLines;
+function countLines(string, startIndex = 0) {
+  let lines = 1;
+  for (let i = startIndex; i < string.length; i++) {
+    if (string.charAt(i) === '\n') {
+      lines++;
+    }
+  }
+  return lines;
+}

package/lib/debounce.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = debounce;
+function debounce(fn, delay) {
+  let timeout;
+  return function (...args) {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+    timeout = setTimeout(() => {
+      timeout = null;
+      fn(...args);
+    }, delay);
+  };
+}

package/lib/debug-tools.js

@@ -0,0 +1,36 @@
+"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
+};
+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 {
+    throw new Error(`Invalid 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
+  };
+}