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

package/lib/is-url.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isURL;
+function _isUrl() {
+  const data = _interopRequireDefault(require("is-url"));
+  _isUrl = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// Matches anchor (ie: #raptors)
+const ANCHOR_REGEXP = /^#/;
+
+// Matches scheme (ie: tel:, mailto:, data:, itms-apps:)
+const SCHEME_REGEXP = /^[a-z][a-z0-9\-+.]*:/i;
+function isURL(url) {
+  return (0, _isUrl().default)(url) || ANCHOR_REGEXP.test(url) || SCHEME_REGEXP.test(url);
+}

package/lib/isDirectoryInside.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isDirectoryInside;
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function isDirectoryInside(child, parent) {
+  const relative = _path().default.relative(parent, child);
+  return !relative.startsWith('..') && !_path().default.isAbsolute(relative);
+}

package/lib/objectHash.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = objectHash;
+function _crypto() {
+  const data = _interopRequireDefault(require("crypto"));
+  _crypto = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// $FlowFixMe
+function objectHash(object) {
+  let hash = _crypto().default.createHash('md5');
+  for (let key of Object.keys(object).sort()) {
+    let val = object[key];
+    if (typeof val === 'object' && val) {
+      hash.update(key + objectHash(val));
+    } else {
+      hash.update(key + val);
+    }
+  }
+  return hash.digest('hex');
+}

package/lib/openInBrowser.js

@@ -0,0 +1,74 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = openInBrowser;
+function _open() {
+  const data = _interopRequireDefault(require("open"));
+  _open = function () {
+    return data;
+  };
+  return data;
+}
+function _child_process() {
+  const data = require("child_process");
+  _child_process = 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 }; }
+// Chrome app name is platform dependent. we should not hard code it.
+// https://github.com/react-native-community/cli/blob/e2be8a905285d9b37512fc78c9755b9635ecf805/packages/cli/src/commands/server/launchDebugger.ts#L28
+function getChromeAppName() {
+  switch (process.platform) {
+    case 'darwin':
+      return 'google chrome';
+    case 'win32':
+      return 'chrome';
+    case 'linux':
+      if (commandExistsUnixSync('google-chrome')) {
+        return 'google-chrome';
+      }
+      if (commandExistsUnixSync('chromium-browser')) {
+        return 'chromium-browser';
+      }
+      return 'chromium';
+    default:
+      return 'google-chrome';
+  }
+}
+function commandExistsUnixSync(commandName) {
+  try {
+    const stdout = (0, _child_process().execSync)(`command -v ${commandName} 2>/dev/null` + ` && { echo >&1 '${commandName} found'; exit 0; }`);
+    return !!stdout;
+  } catch (error) {
+    return false;
+  }
+}
+function getAppName(appName) {
+  if (['google', 'chrome'].includes(appName)) {
+    return getChromeAppName();
+  } else if (['brave', 'Brave'].includes(appName)) {
+    return 'Brave Browser';
+  } else return appName;
+}
+async function openInBrowser(url, browser) {
+  try {
+    const options = typeof browser === 'string' && browser.length > 0 ? {
+      app: [getAppName(browser)]
+    } : undefined;
+    await (0, _open().default)(url, options);
+  } catch (err) {
+    _logger().default.error(`Unexpected error while opening in browser: ${browser}`, '@atlaspack/utils');
+    _logger().default.error(err, '@atlaspack/utils');
+  }
+}

package/lib/parseCSSImport.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = parseCSSImport;
+function parseCSSImport(url) {
+  if (!/^(~|\.\/|\/)/.test(url)) {
+    return './' + url;
+  } else if (!/^(~\/|\.\/|\/)/.test(url)) {
+    return url.substring(1);
+  } else {
+    return url;
+  }
+}

package/lib/path.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isAbsolute = isAbsolute;
+exports.normalizePath = normalizePath;
+exports.normalizeSeparators = normalizeSeparators;
+exports.relativePath = relativePath;
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const ABSOLUTE_PATH_REGEX = /^([a-zA-Z]:){0,1}[\\/]+/;
+const SEPARATOR_REGEX = /[\\]+/g;
+function isAbsolute(filepath) {
+  return ABSOLUTE_PATH_REGEX.test(filepath);
+}
+function normalizeSeparators(filePath) {
+  return filePath.replace(SEPARATOR_REGEX, '/');
+}
+function normalizePath(filePath, leadingDotSlash = true) {
+  if (leadingDotSlash && (filePath[0] !== '.' || filePath[1] !== '.' && filePath[1] !== '/' && filePath[1] !== '\\') && !_path().default.isAbsolute(filePath)) {
+    return normalizeSeparators('./' + filePath);
+  } else {
+    return normalizeSeparators(filePath);
+  }
+}
+function relativePath(from, to, leadingDotSlash = true) {
+  // Fast path
+  if (to.startsWith(from + '/')) {
+    return (leadingDotSlash ? './' : '') + to.slice(from.length + 1);
+  }
+  return normalizePath(_path().default.relative(from, to), leadingDotSlash);
+}

package/lib/prettifyTime.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = prettifyTime;
+function prettifyTime(timeInMs) {
+  return timeInMs < 1000 ? `${timeInMs}ms` : `${(timeInMs / 1000).toFixed(2)}s`;
+}

package/lib/prettyDiagnostic.js

@@ -0,0 +1,136 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = prettyDiagnostic;
+function _codeframe() {
+  const data = _interopRequireDefault(require("@atlaspack/codeframe"));
+  _codeframe = function () {
+    return data;
+  };
+  return data;
+}
+function _markdownAnsi() {
+  const data = _interopRequireDefault(require("@atlaspack/markdown-ansi"));
+  _markdownAnsi = function () {
+    return data;
+  };
+  return data;
+}
+function _chalk2() {
+  const data = _interopRequireDefault(require("chalk"));
+  _chalk2 = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _terminalLink2() {
+  const data = _interopRequireDefault(require("terminal-link"));
+  _terminalLink2 = function () {
+    return data;
+  };
+  return data;
+}
+function _snarkdown() {
+  const data = _interopRequireDefault(require("snarkdown"));
+  _snarkdown = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// $FlowFixMe
+/* eslint-disable import/no-extraneous-dependencies */
+// $FlowFixMe
+/* eslint-enable import/no-extraneous-dependencies */
+async function prettyDiagnostic(diagnostic, options, terminalWidth, format = 'ansi') {
+  let {
+    origin,
+    message,
+    stack,
+    codeFrames,
+    hints,
+    skipFormatting,
+    documentationURL
+  } = diagnostic;
+  const md = format === 'ansi' ? _markdownAnsi().default : _snarkdown().default;
+  const terminalLink = format === 'ansi' ? _terminalLink2().default :
+  // eslint-disable-next-line no-unused-vars
+  (text, url, _) => `<a href="${url}">${text}</a>`;
+  const chalk = format === 'ansi' ? _chalk2().default : {
+    gray: {
+      underline: v => `<span style="color: grey; text-decoration: underline;">${v}</span>`
+    }
+  };
+  let result = {
+    message: md(`**${origin ?? 'unknown'}**: `) + (skipFormatting ? message : md(message)),
+    stack: '',
+    codeframe: '',
+    frames: [],
+    hints: [],
+    documentation: ''
+  };
+  if (codeFrames != null) {
+    for (let codeFrame of codeFrames) {
+      let filePath = codeFrame.filePath;
+      if (filePath != null && options && !_path().default.isAbsolute(filePath)) {
+        filePath = _path().default.join(options.projectRoot, filePath);
+      }
+      let highlights = codeFrame.codeHighlights;
+      let code = codeFrame.code;
+      if (code == null && options && filePath != null) {
+        code = await options.inputFS.readFile(filePath, 'utf8');
+      }
+      let formattedCodeFrame = '';
+      if (code != null) {
+        formattedCodeFrame = (0, _codeframe().default)(code, highlights, {
+          useColor: true,
+          syntaxHighlighting: true,
+          language:
+          // $FlowFixMe sketchy null checks do not matter here...
+          codeFrame.language || (filePath != null ? _path().default.extname(filePath).substr(1) : undefined),
+          terminalWidth
+        });
+      }
+      let location;
+      if (typeof filePath !== 'string') {
+        location = '';
+      } else if (highlights.length === 0) {
+        location = filePath;
+      } else {
+        location = `${filePath}:${highlights[0].start.line}:${highlights[0].start.column}`;
+      }
+      result.codeframe += location ? chalk.gray.underline(location) + '\n' : '';
+      result.codeframe += formattedCodeFrame;
+      if (codeFrame !== codeFrames[codeFrames.length - 1]) {
+        result.codeframe += '\n\n';
+      }
+      result.frames.push({
+        location,
+        code: formattedCodeFrame
+      });
+    }
+  }
+  if (stack != null) {
+    result.stack = stack;
+  }
+  if (Array.isArray(hints) && hints.length) {
+    result.hints = hints.map(h => {
+      return md(h);
+    });
+  }
+  if (documentationURL != null) {
+    result.documentation = terminalLink('Learn more', documentationURL, {
+      fallback: (text, url) => `${text}: ${url}`
+    });
+  }
+  return result;
+}

package/lib/progress-message.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getProgressMessage = getProgressMessage;
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function getProgressMessage(event) {
+  switch (event.phase) {
+    case 'transforming':
+      return `Building ${_path().default.basename(event.filePath)}...`;
+    case 'bundling':
+      return 'Bundling...';
+    case 'packaging':
+      return `Packaging ${event.bundle.displayName}...`;
+    case 'optimizing':
+      return `Optimizing ${event.bundle.displayName}...`;
+  }
+  return null;
+}

package/lib/relativeBundlePath.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.relativeBundlePath = relativeBundlePath;
+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 }; }
+function relativeBundlePath(from, to, opts = {
+  leadingDotSlash: true
+}) {
+  let fromPath = _path().default.join(from.target.distDir, from.name);
+  let toPath = _path().default.join(to.target.distDir, to.name);
+  return (0, _path2.relativePath)(_path().default.dirname(fromPath), toPath, opts.leadingDotSlash);
+}

package/lib/relativeUrl.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = relativeUrl;
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _url() {
+  const data = _interopRequireDefault(require("url"));
+  _url = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function relativeUrl(from, to) {
+  return _url().default.format(_url().default.parse(_path().default.relative(from, to)));
+}

package/lib/replaceBundleReferences.js

@@ -0,0 +1,199 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getURLReplacement = getURLReplacement;
+exports.replaceInlineReferences = replaceInlineReferences;
+exports.replaceURLReferences = replaceURLReferences;
+function _rust() {
+  const data = require("@atlaspack/rust");
+  _rust = function () {
+    return data;
+  };
+  return data;
+}
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
+function _stream() {
+  const data = require("stream");
+  _stream = function () {
+    return data;
+  };
+  return data;
+}
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+  _assert = function () {
+    return data;
+  };
+  return data;
+}
+function _url() {
+  const data = _interopRequireDefault(require("url"));
+  _url = function () {
+    return data;
+  };
+  return data;
+}
+var _ = require("./");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/*
+ * Replaces references to dependency ids for URL dependencies with:
+ *   - in the case of an unresolvable url dependency, the original specifier.
+ *     These are external requests that Parcel did not bundle.
+ *   - in the case of a reference to another bundle, the relative url to that
+ *     bundle from the current bundle.
+ */
+function replaceURLReferences({
+  bundle,
+  bundleGraph,
+  contents,
+  map,
+  getReplacement = s => s,
+  relative = true
+}) {
+  let replacements = new Map();
+  let urlDependencies = [];
+  bundle.traverse(node => {
+    if (node.type === 'dependency' && node.value.specifierType === 'url') {
+      urlDependencies.push(node.value);
+    }
+  });
+  for (let dependency of urlDependencies) {
+    var _dependency$meta;
+    if (dependency.specifierType !== 'url') {
+      continue;
+    }
+    let placeholder = ((_dependency$meta = dependency.meta) === null || _dependency$meta === void 0 ? void 0 : _dependency$meta.placeholder) ?? dependency.id;
+    (0, _assert().default)(typeof placeholder === 'string');
+    let resolved = bundleGraph.getReferencedBundle(dependency, bundle);
+    if (resolved == null) {
+      replacements.set(placeholder, {
+        from: placeholder,
+        to: getReplacement(dependency.specifier)
+      });
+      continue;
+    }
+    if (resolved.bundleBehavior === 'inline') {
+      // If a bundle is inline, it should be replaced with inline contents,
+      // not a URL.
+      continue;
+    }
+    replacements.set(placeholder, getURLReplacement({
+      dependency,
+      fromBundle: bundle,
+      toBundle: resolved,
+      relative,
+      getReplacement
+    }));
+  }
+  return performReplacement(replacements, contents, map);
+}
+
+/*
+ * Replaces references to dependency ids for inline bundles with the packaged
+ * contents of that bundle.
+ */
+async function replaceInlineReferences({
+  bundle,
+  bundleGraph,
+  contents,
+  map,
+  getInlineReplacement,
+  getInlineBundleContents
+}) {
+  let replacements = new Map();
+  let dependencies = [];
+  bundle.traverse(node => {
+    if (node.type === 'dependency') {
+      dependencies.push(node.value);
+    }
+  });
+  for (let dependency of dependencies) {
+    let entryBundle = bundleGraph.getReferencedBundle(dependency, bundle);
+    if ((entryBundle === null || entryBundle === void 0 ? void 0 : entryBundle.bundleBehavior) !== 'inline') {
+      continue;
+    }
+    let packagedBundle = await getInlineBundleContents(entryBundle, bundleGraph);
+    let packagedContents = (packagedBundle.contents instanceof _stream().Readable ? await (0, _.bufferStream)(packagedBundle.contents) : packagedBundle.contents).toString();
+    let inlineType = (0, _nullthrows().default)(entryBundle.getMainEntry()).meta.inlineType;
+    if (inlineType == null || inlineType === 'string') {
+      var _dependency$meta2;
+      let placeholder = ((_dependency$meta2 = dependency.meta) === null || _dependency$meta2 === void 0 ? void 0 : _dependency$meta2.placeholder) ?? dependency.id;
+      (0, _assert().default)(typeof placeholder === 'string');
+      replacements.set(placeholder, getInlineReplacement(dependency, inlineType, packagedContents));
+    }
+  }
+  return performReplacement(replacements, contents, map);
+}
+function getURLReplacement({
+  dependency,
+  fromBundle,
+  toBundle,
+  relative,
+  getReplacement
+}) {
+  var _dependency$meta3;
+  let to;
+  let orig = _url().default.parse(dependency.specifier);
+  if (relative) {
+    to = _url().default.format({
+      pathname: (0, _.relativeBundlePath)(fromBundle, toBundle, {
+        leadingDotSlash: false
+      }),
+      hash: orig.hash
+    });
+
+    // If the resulting path includes a colon character and doesn't start with a ./ or ../
+    // we need to add one so that the first part before the colon isn't parsed as a URL protocol.
+    if (to.includes(':') && !to.startsWith('./') && !to.startsWith('../')) {
+      to = './' + to;
+    }
+  } else {
+    to = (0, _.urlJoin)(toBundle.target.publicUrl, _url().default.format({
+      pathname: (0, _nullthrows().default)(toBundle.name),
+      hash: orig.hash
+    }));
+  }
+  let placeholder = ((_dependency$meta3 = dependency.meta) === null || _dependency$meta3 === void 0 ? void 0 : _dependency$meta3.placeholder) ?? dependency.id;
+  (0, _assert().default)(typeof placeholder === 'string');
+  return {
+    from: placeholder,
+    to: getReplacement ? getReplacement(to) : to
+  };
+}
+function performReplacement(replacements, contents, map) {
+  let finalContents = contents;
+  if ((0, _featureFlags().getFeatureFlag)('inlineStringReplacementPerf')) {
+    let replacementList = Array.from(replacements.values());
+    if (replacementList.length > 0) {
+      finalContents = (0, _rust().performStringReplacements)(contents, replacementList);
+    }
+  } else {
+    for (let {
+      from,
+      to
+    } of replacements.values()) {
+      // Perform replacement
+      finalContents = finalContents.split(from).join(to);
+    }
+  }
+  return {
+    contents: finalContents,
+    // TODO: Update sourcemap with adjusted contents
+    map
+  };
+}