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

package/lib/is-url.d.ts

@@ -0,0 +1 @@
+export default function isURL(url: string): boolean;

package/lib/is-url.js

@@ -0,0 +1,24 @@
+"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 }; }
+// @ts-expect-error TS7016
+
+// 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.d.ts

@@ -0,0 +1,2 @@
+import type { FilePath } from '@atlaspack/types';
+export default function isDirectoryInside(child: FilePath, parent: FilePath): boolean;

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.d.ts

@@ -0,0 +1,3 @@
+type Hashable = any;
+export default function objectHash(object: Hashable): string;
+export {};

package/lib/objectHash.js

@@ -0,0 +1,26 @@
+"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 }; }
+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.d.ts

@@ -0,0 +1 @@
+export default function openInBrowser(url: string, browser: string): Promise<void>;

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.d.ts

@@ -0,0 +1 @@
+export default function parseCSSImport(url: string): string;

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.d.ts

@@ -0,0 +1,8 @@
+import type { FilePath } from '@atlaspack/types';
+export declare function isAbsolute(filepath: string): boolean;
+export declare function normalizeSeparators(filePath: FilePath): FilePath;
+export type PathOptions = {
+    noLeadingDotSlash?: boolean;
+};
+export declare function normalizePath(filePath: FilePath, leadingDotSlash?: boolean): FilePath;
+export declare function relativePath(from: string, to: string, leadingDotSlash?: boolean): FilePath;

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.d.ts

@@ -0,0 +1 @@
+export default function prettifyTime(timeInMs: number): string;

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.d.ts

@@ -0,0 +1,17 @@
+import type { Diagnostic } from '@atlaspack/diagnostic';
+import type { PluginOptions } from '@atlaspack/types';
+export type FormattedCodeFrame = {
+    location: string;
+    code: string;
+};
+export type AnsiDiagnosticResult = {
+    message: string;
+    stack: string;
+    /** A formatted string containing all code frames, including their file locations. */
+    codeframe: string;
+    /** A list of code frames with highlighted code and file locations separately. */
+    frames: Array<FormattedCodeFrame>;
+    hints: Array<string>;
+    documentation: string;
+};
+export default function prettyDiagnostic(diagnostic: Diagnostic, options?: PluginOptions, terminalWidth?: number, format?: 'ansi' | 'html'): Promise<AnsiDiagnosticResult>;

package/lib/prettyDiagnostic.js

@@ -0,0 +1,134 @@
+"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 }; }
+/* eslint-disable import/no-extraneous-dependencies */
+
+/* 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: 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.d.ts

@@ -0,0 +1,3 @@
+import type { BuildProgressEvent } from '@atlaspack/types';
+export declare function getProgressMessage(event: BuildProgressEvent): string | null | undefined;
+export declare function getPackageProgressMessage(completeBundles: number, totalBundles: number): string;

package/lib/progress-message.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getPackageProgressMessage = getPackageProgressMessage;
+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}...`;
+    case 'packagingAndOptimizing':
+      {
+        return getPackageProgressMessage(event.completeBundles, event.totalBundles);
+      }
+  }
+  return null;
+}
+function getPackageProgressMessage(completeBundles, totalBundles) {
+  let percent = Math.floor(completeBundles / totalBundles * 100);
+  return `Packaging bundles ${completeBundles}/${totalBundles} (${percent}%)`;
+}

package/lib/relativeBundlePath.d.ts

@@ -0,0 +1,4 @@
+import type { FilePath, NamedBundle } from '@atlaspack/types';
+export declare function relativeBundlePath(from: NamedBundle, to: NamedBundle, opts?: {
+    leadingDotSlash: boolean;
+}): FilePath;

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.d.ts

@@ -0,0 +1 @@
+export default function relativeUrl(from: string, to: string): string;

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.d.ts

@@ -0,0 +1,39 @@
+import type SourceMap from '@parcel/source-map';
+import type { Async, Blob, Bundle, BundleGraph, Dependency, NamedBundle } from '@atlaspack/types';
+export declare function replaceURLReferences({ bundle, bundleGraph, contents, map, getReplacement, relative, }: {
+    bundle: NamedBundle;
+    bundleGraph: BundleGraph<NamedBundle>;
+    contents: string;
+    relative?: boolean;
+    map?: SourceMap | null | undefined;
+    getReplacement?: (arg1: string) => string;
+}): {
+    readonly contents: string;
+    readonly map: SourceMap | null | undefined;
+};
+export declare function replaceInlineReferences({ bundle, bundleGraph, contents, map, getInlineReplacement, getInlineBundleContents, }: {
+    bundle: Bundle;
+    bundleGraph: BundleGraph<NamedBundle>;
+    contents: string;
+    getInlineReplacement: (arg1: Dependency, arg2: 'string' | null | undefined, arg3: string) => {
+        from: string;
+        to: string;
+    };
+    getInlineBundleContents: (arg1: Bundle, arg2: BundleGraph<NamedBundle>) => Async<{
+        contents: Blob;
+    }>;
+    map?: SourceMap | null | undefined;
+}): Promise<{
+    readonly contents: string;
+    readonly map: SourceMap | null | undefined;
+}>;
+export declare function getURLReplacement({ dependency, fromBundle, toBundle, relative, getReplacement, }: {
+    dependency: Dependency;
+    fromBundle: NamedBundle;
+    toBundle: NamedBundle;
+    relative: boolean;
+    getReplacement?: (arg1: string) => string;
+}): {
+    from: string;
+    to: string;
+};