@atlaspack/utils 2.19.3 → 3.0.0

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @atlaspack/utils
 
+## 3.0.0
+
+### Major Changes
+
+- [#800](https://github.com/atlassian-labs/atlaspack/pull/800) [`1180103`](https://github.com/atlassian-labs/atlaspack/commit/118010351ed444f8178988afb3f77807154dd933) Thanks [@mattcompiles](https://github.com/mattcompiles)! - Fix errors when creating diagnostics with relative file paths
+
+  BREAKING CHANGE: The `remapSourceLocation` API in `@atlaspack/utils` now requires the project root
+
+### Patch Changes
+
+- Updated dependencies [[`0207171`](https://github.com/atlassian-labs/atlaspack/commit/0207171e59e985c51e105aec2e0a99de174374bd), [`10ee3fa`](https://github.com/atlassian-labs/atlaspack/commit/10ee3fa5b75a92acde8973673d9b3c5b6f3958e5), [`bbe4e28`](https://github.com/atlassian-labs/atlaspack/commit/bbe4e28c89e5e9284bd730075d4d6f2a3cb37b21), [`1180103`](https://github.com/atlassian-labs/atlaspack/commit/118010351ed444f8178988afb3f77807154dd933), [`2bc93b1`](https://github.com/atlassian-labs/atlaspack/commit/2bc93b17cea07fd7cbb68acec84d8471345a22b4)]:
+  - @atlaspack/feature-flags@2.25.2
+  - @atlaspack/rust@3.8.2
+  - @atlaspack/types-internal@2.20.2
+  - @atlaspack/logger@2.14.24
+  - @atlaspack/codeframe@2.13.14
+
 ## 2.19.3
 
 ### Patch Changes

package/dist/DefaultMap.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultWeakMap = exports.DefaultMap = void 0;
+class DefaultMap extends Map {
+    constructor(getDefault, entries) {
+        super(entries);
+        this._getDefault = getDefault;
+    }
+    get(key) {
+        let ret;
+        if (this.has(key)) {
+            ret = super.get(key);
+        }
+        else {
+            ret = this._getDefault(key);
+            this.set(key, ret);
+        }
+        return ret;
+    }
+}
+exports.DefaultMap = DefaultMap;
+// Duplicated from DefaultMap implementation for Flow
+// Roughly mirrors https://github.com/facebook/flow/blob/2eb5a78d92c167117ba9caae070afd2b9f598599/lib/core.js#L617
+class DefaultWeakMap extends WeakMap {
+    constructor(getDefault, entries) {
+        super(entries);
+        this._getDefault = getDefault;
+    }
+    get(key) {
+        let ret;
+        if (this.has(key)) {
+            ret = super.get(key);
+        }
+        else {
+            ret = this._getDefault(key);
+            this.set(key, ret);
+        }
+        return ret;
+    }
+}
+exports.DefaultWeakMap = DefaultWeakMap;

package/dist/Deferred.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDeferredWithPromise = makeDeferredWithPromise;
+const assert_1 = __importDefault(require("assert"));
+function makeDeferredWithPromise() {
+    let deferred;
+    let promise = new Promise((resolve, reject) => {
+        deferred = { resolve, reject };
+    });
+    // Promise constructor callback executes synchronously, so this is defined
+    (0, assert_1.default)(deferred != null);
+    return { deferred, promise };
+}

package/dist/PromiseQueue.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Deferred_1 = require("./Deferred");
+class PromiseQueue {
+    constructor(opts = { maxConcurrent: Infinity }) {
+        this._numRunning = 0;
+        this._queue = [];
+        this._runPromise = null;
+        this._count = 0;
+        this._results = [];
+        this._addSubscriptions = new Set();
+        if (opts.maxConcurrent <= 0) {
+            throw new TypeError('maxConcurrent must be a positive, non-zero value');
+        }
+        this._maxConcurrent = opts.maxConcurrent;
+    }
+    getNumWaiting() {
+        return this._queue.length;
+    }
+    add(fn) {
+        new Promise((resolve, reject) => {
+            let i = this._count++;
+            let wrapped = () => fn().then((result) => {
+                this._results[i] = result;
+                resolve(result);
+            }, (err) => {
+                reject(err);
+                throw err;
+            });
+            this._queue.push(wrapped);
+            for (const addFn of this._addSubscriptions) {
+                addFn();
+            }
+            if (this._numRunning > 0 && this._numRunning < this._maxConcurrent) {
+                this._next();
+            }
+        }).catch(() => { });
+    }
+    subscribeToAdd(fn) {
+        this._addSubscriptions.add(fn);
+        return () => {
+            this._addSubscriptions.delete(fn);
+        };
+    }
+    run() {
+        if (this._runPromise != null) {
+            return this._runPromise;
+        }
+        if (this._queue.length === 0) {
+            return Promise.resolve([]);
+        }
+        let { deferred, promise } = (0, Deferred_1.makeDeferredWithPromise)();
+        this._deferred = deferred;
+        this._runPromise = promise;
+        while (this._queue.length && this._numRunning < this._maxConcurrent) {
+            this._next();
+        }
+        return promise;
+    }
+    async _next() {
+        let fn = this._queue.shift();
+        await this._runFn(fn);
+        if (this._queue.length) {
+            this._next();
+        }
+        else if (this._numRunning === 0) {
+            this._done();
+        }
+    }
+    async _runFn(fn) {
+        this._numRunning++;
+        try {
+            await fn();
+        }
+        catch (e) {
+            // Only store the first error that occurs.
+            // We don't reject immediately so that any other concurrent
+            // requests have time to complete.
+            if (this._error == null) {
+                this._error = e;
+            }
+        }
+        finally {
+            this._numRunning--;
+        }
+    }
+    _resetState() {
+        this._queue = [];
+        this._count = 0;
+        this._results = [];
+        this._runPromise = null;
+        this._numRunning = 0;
+        this._deferred = null;
+    }
+    _done() {
+        if (this._deferred != null) {
+            if (this._error != null) {
+                this._deferred.reject(this._error);
+            }
+            else {
+                this._deferred.resolve(this._results);
+            }
+        }
+        this._resetState();
+    }
+}
+exports.default = PromiseQueue;

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);
+    };
+}