@atlaspack/utils 2.14.5-canary.34 → 2.14.5-canary.341

package/dist/objectHash.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = objectHash;
+const crypto_1 = __importDefault(require("crypto"));
+function objectHash(object) {
+    let hash = crypto_1.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/dist/openInBrowser.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = openInBrowser;
+const open_1 = __importDefault(require("open"));
+const child_process_1 = require("child_process");
+const logger_1 = __importDefault(require("@atlaspack/logger"));
+// 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_1.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_1.default)(url, options);
+    }
+    catch (err) {
+        logger_1.default.error(`Unexpected error while opening in browser: ${browser}`, '@atlaspack/utils');
+        logger_1.default.error(err, '@atlaspack/utils');
+    }
+}

package/dist/parseCSSImport.js

@@ -0,0 +1,14 @@
+"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/dist/path.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAbsolute = isAbsolute;
+exports.normalizeSeparators = normalizeSeparators;
+exports.normalizePath = normalizePath;
+exports.relativePath = relativePath;
+const path_1 = __importDefault(require("path"));
+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_1.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_1.default.relative(from, to), leadingDotSlash);
+}

package/dist/prettifyTime.js

@@ -0,0 +1,6 @@
+"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/dist/prettyDiagnostic.js

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = prettyDiagnostic;
+const codeframe_1 = __importDefault(require("@atlaspack/codeframe"));
+const logger_1 = __importDefault(require("@atlaspack/logger"));
+const markdown_ansi_1 = __importDefault(require("@atlaspack/markdown-ansi"));
+const chalk_1 = __importDefault(require("chalk"));
+const path_1 = __importDefault(require("path"));
+const terminal_link_1 = __importDefault(require("terminal-link"));
+/* eslint-disable import/no-extraneous-dependencies */
+const snarkdown_1 = __importDefault(require("snarkdown"));
+async function prettyDiagnostic(diagnostic, options, terminalWidth, format = 'ansi') {
+    let { origin, message, stack, codeFrames, hints, skipFormatting, documentationURL, } = diagnostic;
+    const md = format === 'ansi' ? markdown_ansi_1.default : snarkdown_1.default;
+    const terminalLink = format === 'ansi'
+        ? terminal_link_1.default
+        : // eslint-disable-next-line no-unused-vars
+            (text, url, _) => `<a href="${url}">${text}</a>`;
+    const chalk = format === 'ansi'
+        ? chalk_1.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_1.default.isAbsolute(filePath)) {
+                filePath = path_1.default.join(options.projectRoot, filePath);
+            }
+            let highlights = codeFrame.codeHighlights;
+            let code = codeFrame.code;
+            if (code == null && options && filePath != null) {
+                try {
+                    code = await options.inputFS.readFile(filePath, 'utf8');
+                }
+                catch (e) {
+                    // In strange cases this can fail and hide the underlying error.
+                    logger_1.default.warn({
+                        origin: '@atlaspack/utils',
+                        message: `Failed to read file for generating codeframe: "${filePath}"`,
+                        skipFormatting: true,
+                    });
+                }
+            }
+            let formattedCodeFrame = '';
+            if (code != null) {
+                formattedCodeFrame = (0, codeframe_1.default)(code, highlights, {
+                    useColor: true,
+                    syntaxHighlighting: true,
+                    language: codeFrame.language ||
+                        (filePath != null ? path_1.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/dist/progress-message.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProgressMessage = getProgressMessage;
+exports.getPackageProgressMessage = getPackageProgressMessage;
+const path_1 = __importDefault(require("path"));
+function getProgressMessage(event) {
+    switch (event.phase) {
+        case 'transforming':
+            return `Building ${path_1.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);
+    let completeStr = completeBundles.toString();
+    let totalStr = totalBundles.toString();
+    let displayBundles = completeStr.padStart(totalStr.length, ' ');
+    return `Packaging bundles ${displayBundles}/${totalBundles} (${percent}%)`;
+}

package/dist/relativeBundlePath.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.relativeBundlePath = relativeBundlePath;
+const path_1 = __importDefault(require("path"));
+const path_2 = require("./path");
+function relativeBundlePath(from, to, opts = { leadingDotSlash: true }) {
+    let fromPath = path_1.default.join(from.target.distDir, from.name);
+    let toPath = path_1.default.join(to.target.distDir, to.name);
+    return (0, path_2.relativePath)(path_1.default.dirname(fromPath), toPath, opts.leadingDotSlash);
+}

package/dist/relativeUrl.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = relativeUrl;
+const path_1 = __importDefault(require("path"));
+const url_1 = __importDefault(require("url"));
+function relativeUrl(from, to) {
+    return url_1.default.format(url_1.default.parse(path_1.default.relative(from, to)));
+}

package/dist/replaceBundleReferences.js

@@ -0,0 +1,131 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceURLReferences = replaceURLReferences;
+exports.replaceInlineReferences = replaceInlineReferences;
+exports.getURLReplacement = getURLReplacement;
+const rust_1 = require("@atlaspack/rust");
+const stream_1 = require("stream");
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const assert_1 = __importDefault(require("assert"));
+const url_1 = __importDefault(require("url"));
+const _1 = require("./");
+/*
+ * 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) {
+        if (dependency.specifierType !== 'url') {
+            continue;
+        }
+        let placeholder = dependency.meta?.placeholder ?? dependency.id;
+        (0, assert_1.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' ||
+            resolved.bundleBehavior === 'inlineIsolated') {
+            // 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?.bundleBehavior !== 'inline' &&
+            entryBundle?.bundleBehavior !== 'inlineIsolated') {
+            continue;
+        }
+        let packagedBundle = await getInlineBundleContents(entryBundle, bundleGraph);
+        let packagedContents = (packagedBundle.contents instanceof stream_1.Readable
+            ? await (0, _1.bufferStream)(packagedBundle.contents)
+            : packagedBundle.contents).toString();
+        let inlineType = (0, nullthrows_1.default)(entryBundle.getMainEntry()).meta.inlineType;
+        if (inlineType == null || inlineType === 'string') {
+            let placeholder = dependency.meta?.placeholder ?? dependency.id;
+            (0, assert_1.default)(typeof placeholder === 'string');
+            replacements.set(placeholder, getInlineReplacement(dependency, inlineType, packagedContents));
+        }
+    }
+    return performReplacement(replacements, contents, map);
+}
+function getURLReplacement({ dependency, fromBundle, toBundle, relative, getReplacement, }) {
+    let to;
+    let orig = url_1.default.parse(dependency.specifier);
+    if (relative) {
+        to = url_1.default.format({
+            pathname: (0, _1.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, _1.urlJoin)(toBundle.target.publicUrl, url_1.default.format({
+            pathname: (0, nullthrows_1.default)(toBundle.name),
+            hash: orig.hash,
+        }));
+    }
+    let placeholder = dependency.meta?.placeholder ?? dependency.id;
+    (0, assert_1.default)(typeof placeholder === 'string');
+    return {
+        from: placeholder,
+        to: getReplacement ? getReplacement(to) : to,
+    };
+}
+function performReplacement(replacements, contents, map) {
+    let finalContents = contents;
+    let replacementList = Array.from(replacements.values());
+    if (replacementList.length > 0) {
+        finalContents = (0, rust_1.performStringReplacements)(contents, replacementList);
+    }
+    return {
+        contents: finalContents,
+        // TODO: Update sourcemap with adjusted contents
+        map,
+    };
+}