@atlaspack/utils 2.14.5-canary.35 → 2.14.5-canary.351

package/dist/TapStream.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const stream_1 = require("stream");
+/*
+ * "Taps" into the contents of a flowing stream, yielding chunks to the passed
+ * callback. Continues to pass data chunks down the stream.
+ */
+class TapStream extends stream_1.Transform {
+    constructor(tap, options) {
+        super({ ...options });
+        this._tap = tap;
+    }
+    _transform(chunk, encoding, callback) {
+        try {
+            this._tap(Buffer.from(chunk));
+            callback(null, chunk);
+        }
+        catch (err) {
+            callback(err);
+        }
+    }
+}
+exports.default = TapStream;

package/dist/alternatives.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findAlternativeNodeModules = findAlternativeNodeModules;
+exports.findAlternativeFiles = findAlternativeFiles;
+const path_1 = __importDefault(require("path"));
+const schema_1 = require("./schema");
+const path_2 = require("./path");
+const config_1 = require("./config");
+async function findAlternativeNodeModules(fs, moduleName, dir) {
+    let potentialModules = [];
+    let root = path_1.default.parse(dir).root;
+    let isOrganisationModule = moduleName.startsWith('@');
+    while (dir !== root) {
+        // Skip node_modules directories
+        if (path_1.default.basename(dir) === 'node_modules') {
+            dir = path_1.default.dirname(dir);
+        }
+        try {
+            let modulesDir = path_1.default.join(dir, 'node_modules');
+            let stats = await fs.stat(modulesDir);
+            if (stats.isDirectory()) {
+                let dirContent = (await fs.readdir(modulesDir)).sort();
+                // Filter out the modules that interest us
+                let modules = dirContent.filter((i) => isOrganisationModule ? i.startsWith('@') : !i.startsWith('@'));
+                // If it's an organisation module, loop through all the modules of that organisation
+                if (isOrganisationModule) {
+                    await Promise.all(modules.map(async (item) => {
+                        let orgDirPath = path_1.default.join(modulesDir, item);
+                        let orgDirContent = (await fs.readdir(orgDirPath)).sort();
+                        // Add all org packages
+                        potentialModules.push(...orgDirContent.map((i) => `${item}/${i}`));
+                    }));
+                }
+                else {
+                    potentialModules.push(...modules);
+                }
+            }
+        }
+        catch (err) {
+            // ignore
+        }
+        // Move up a directory
+        dir = path_1.default.dirname(dir);
+    }
+    return (0, schema_1.fuzzySearch)(potentialModules.sort(), moduleName).slice(0, 2);
+}
+async function findAllFilesUp({ fs, dir, root, basedir, maxlength, collected, leadingDotSlash = true, includeDirectories = true, }) {
+    let dirContent = (await fs.readdir(dir)).sort();
+    return Promise.all(dirContent.map(async (item) => {
+        let fullPath = path_1.default.join(dir, item);
+        let relativeFilePath = (0, path_2.relativePath)(basedir, fullPath, leadingDotSlash);
+        if (relativeFilePath.length < maxlength) {
+            let stats = await fs.stat(fullPath);
+            let isDir = stats.isDirectory();
+            if ((isDir && includeDirectories) || stats.isFile()) {
+                collected.push(relativeFilePath);
+            }
+            // If it's a directory, run over each item within said directory...
+            if (isDir) {
+                return findAllFilesUp({
+                    fs,
+                    dir: fullPath,
+                    root,
+                    basedir,
+                    maxlength,
+                    collected,
+                });
+            }
+        }
+    }));
+}
+async function findAlternativeFiles(fs, fileSpecifier, dir, projectRoot, leadingDotSlash = true, includeDirectories = true, includeExtension = false) {
+    let potentialFiles = [];
+    // Find our root, we won't recommend files above the package root as that's bad practise
+    let pkg = await (0, config_1.resolveConfig)(fs, path_1.default.join(dir, 'index'), ['package.json'], projectRoot);
+    let pkgRoot = pkg ? path_1.default.dirname(pkg) : projectRoot;
+    await findAllFilesUp({
+        fs,
+        dir: pkgRoot,
+        root: pkgRoot,
+        basedir: dir,
+        maxlength: fileSpecifier.length + 10,
+        collected: potentialFiles,
+        leadingDotSlash,
+        includeDirectories,
+    });
+    if (path_1.default.extname(fileSpecifier) === '' && !includeExtension) {
+        potentialFiles = potentialFiles.map((p) => {
+            let ext = path_1.default.extname(p);
+            return ext.length > 0 ? p.slice(0, -ext.length) : p;
+        });
+    }
+    return (0, schema_1.fuzzySearch)(potentialFiles.sort(), fileSpecifier).slice(0, 2);
+}

package/dist/ansi-html.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ansiHtml = ansiHtml;
+// @ts-expect-error ansi-html-community is not typed
+const ansi_html_community_1 = __importDefault(require("ansi-html-community"));
+const escape_html_1 = require("./escape-html");
+function ansiHtml(ansi) {
+    return (0, ansi_html_community_1.default)((0, escape_html_1.escapeHTML)(ansi));
+}

package/dist/blob.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blobToBuffer = blobToBuffer;
+exports.blobToString = blobToString;
+const buffer_1 = require("buffer");
+const _1 = require("./");
+const stream_1 = require("stream");
+function blobToBuffer(blob) {
+    if (blob instanceof stream_1.Readable) {
+        return (0, _1.bufferStream)(blob);
+    }
+    else if (blob instanceof buffer_1.Buffer) {
+        return Promise.resolve(buffer_1.Buffer.from(blob));
+    }
+    else {
+        return Promise.resolve(buffer_1.Buffer.from(blob, 'utf8'));
+    }
+}
+async function blobToString(blob) {
+    if (blob instanceof stream_1.Readable) {
+        return (await (0, _1.bufferStream)(blob)).toString();
+    }
+    else if (blob instanceof buffer_1.Buffer) {
+        return blob.toString();
+    }
+    else {
+        return blob;
+    }
+}

package/dist/bundle-url.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBundleURL = void 0;
+exports.getBaseURL = getBaseURL;
+let bundleURL = null;
+function getBundleURLCached() {
+    if (bundleURL == null) {
+        bundleURL = _getBundleURL();
+    }
+    return bundleURL;
+}
+function _getBundleURL() {
+    // Attempt to find the URL of the current script and use that as the base URL
+    try {
+        throw new Error();
+    }
+    catch (err) {
+        let stack = typeof err.stack === 'string' ? err.stack : '';
+        let matches = stack.match(/(https?|file|ftp):\/\/[^)\n]+/g);
+        if (matches) {
+            return getBaseURL(matches[0]);
+        }
+    }
+    return '/';
+}
+function getBaseURL(url) {
+    if (url == null) {
+        return '/';
+    }
+    return url.replace(/^((?:https?|file|ftp):\/\/.+)\/[^/]+$/, '$1') + '/';
+}
+exports.getBundleURL = getBundleURLCached;

package/dist/collection.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unique = unique;
+exports.objectSortedEntries = objectSortedEntries;
+exports.objectSortedEntriesDeep = objectSortedEntriesDeep;
+exports.setDifference = setDifference;
+exports.setSymmetricDifference = setSymmetricDifference;
+exports.setIntersect = setIntersect;
+exports.setIntersectStatic = setIntersectStatic;
+exports.setUnion = setUnion;
+exports.setEqual = setEqual;
+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/dist/config.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveConfig = resolveConfig;
+exports.resolveConfigSync = resolveConfigSync;
+exports.loadConfig = loadConfig;
+exports.readConfig = readConfig;
+const diagnostic_1 = __importDefault(require("@atlaspack/diagnostic"));
+const path_1 = __importDefault(require("path"));
+// @ts-expect-error TS7016
+const clone_1 = __importDefault(require("clone"));
+const json5_1 = __importDefault(require("json5"));
+const toml_1 = require("@iarna/toml");
+const lru_cache_1 = __importDefault(require("lru-cache"));
+// @ts-expect-error TS2351
+const configCache = new lru_cache_1.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_1.default.dirname(filepath) + filenames.join(',');
+    let cached = resolveCache.get(key);
+    if (cached !== undefined) {
+        return Promise.resolve(cached);
+    }
+    let resolved = fs.findAncestorFile(filenames, path_1.default.dirname(filepath), projectRoot);
+    resolveCache.set(key, resolved);
+    return Promise.resolve(resolved);
+}
+function resolveConfigSync(fs, filepath, filenames, projectRoot) {
+    return fs.findAncestorFile(filenames, path_1.default.dirname(filepath), projectRoot);
+}
+async function loadConfig(fs, filepath, filenames, projectRoot, opts) {
+    let parse = 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_1.default.extname(configFile).slice(1);
+            if (extname === 'js' || extname === 'cjs') {
+                let output = {
+                    config: (0, clone_1.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?.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_1.default.extname(configFile).slice(1);
+            let parse = 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_1.default({
+                    diagnostic: {
+                        message: `Failed to parse ${path_1.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_1.parse;
+        case 'json':
+        default:
+            return json5_1.default.parse;
+    }
+}

package/dist/countLines.js

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

@@ -0,0 +1,15 @@
+"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/dist/debug-tools.js

@@ -0,0 +1,39 @@
+"use strict";
+/*
+ * 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`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debugTools = void 0;
+exports.debugTools = {
+    'asset-file-names-in-output': false,
+    'simple-cli-reporter': false,
+    'bundle-stats': false,
+    'scope-hoisting-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 exports.debugTools) {
+            exports.debugTools[key] = true;
+        }
+        break;
+    }
+    else if (exports.debugTools.hasOwnProperty(tool)) {
+        exports.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(exports.debugTools).join(', ')}`);
+    }
+}

package/dist/dependency-location.js

@@ -0,0 +1,22 @@
+"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/dist/escape-html.js

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

@@ -0,0 +1,111 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = generateBuildMetrics;
+const source_map_1 = __importDefault(require("@atlaspack/source-map"));
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const path_1 = __importDefault(require("path"));
+const _1 = require("./");
+async function getSourcemapSizes(filePath, fs, projectRoot) {
+    let bundleContents = await fs.readFile(filePath, 'utf-8');
+    let mapUrlData = await (0, _1.loadSourceMapUrl)(fs, filePath, bundleContents);
+    if (!mapUrlData) {
+        return null;
+    }
+    let rawMap = mapUrlData.map;
+    let sourceMap = new source_map_1.default(projectRoot);
+    sourceMap.addVLQMap(rawMap);
+    let parsedMapData = sourceMap.getMap();
+    if (parsedMapData.mappings.length > 2) {
+        let sources = parsedMapData.sources.map((s) => path_1.default.normalize(path_1.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_1.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_1.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),
+    };
+}