@atlaspack/utils 2.19.2 → 2.19.4-dev-ts-project-refs-d30e9754f.0

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,37 @@
+"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,
+};
+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 {
+        throw new Error(`Invalid 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("@parcel/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),
+    };
+}

package/dist/generateCertificate.js

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = generateCertificate;
+const node_forge_1 = __importDefault(require("node-forge"));
+const path_1 = __importDefault(require("path"));
+const logger_1 = __importDefault(require("@atlaspack/logger"));
+async function generateCertificate(fs, cacheDir, host) {
+    let certDirectory = cacheDir;
+    const privateKeyPath = path_1.default.join(certDirectory, 'private.pem');
+    const certPath = path_1.default.join(certDirectory, 'primary.crt');
+    const cachedKey = (await fs.exists(privateKeyPath)) && (await fs.readFile(privateKeyPath));
+    const cachedCert = (await fs.exists(certPath)) && (await fs.readFile(certPath));
+    if (cachedKey && cachedCert) {
+        return {
+            key: cachedKey,
+            cert: cachedCert,
+        };
+    }
+    logger_1.default.progress('Generating SSL Certificate...');
+    const pki = node_forge_1.default.pki;
+    const keys = pki.rsa.generateKeyPair(2048);
+    const cert = pki.createCertificate();
+    cert.publicKey = keys.publicKey;
+    cert.serialNumber = Date.now().toString();
+    cert.validity.notBefore = new Date();
+    cert.validity.notAfter = new Date();
+    cert.validity.notAfter.setFullYear(cert.validity.notBefore.getFullYear() + 1);
+    const attrs = [
+        {
+            name: 'commonName',
+            value: 'parceljs.org',
+        },
+        {
+            name: 'countryName',
+            value: 'US',
+        },
+        {
+            shortName: 'ST',
+            value: 'Virginia',
+        },
+        {
+            name: 'localityName',
+            value: 'Blacksburg',
+        },
+        {
+            name: 'organizationName',
+            value: 'parcelBundler',
+        },
+        {
+            shortName: 'OU',
+            value: 'Test',
+        },
+    ];
+    let altNames = [
+        {
+            type: 2, // DNS
+            value: 'localhost',
+        },
+        {
+            type: 7, // IP
+            ip: '127.0.0.1',
+        },
+    ];
+    if (host) {
+        altNames.push({
+            type: 2, // DNS
+            value: host,
+        });
+    }
+    cert.setSubject(attrs);
+    cert.setIssuer(attrs);
+    cert.setExtensions([
+        {
+            name: 'basicConstraints',
+            cA: false,
+        },
+        {
+            name: 'keyUsage',
+            keyCertSign: true,
+            digitalSignature: true,
+            nonRepudiation: true,
+            keyEncipherment: true,
+            dataEncipherment: true,
+        },
+        {
+            name: 'extKeyUsage',
+            serverAuth: true,
+            clientAuth: true,
+            codeSigning: true,
+            emailProtection: true,
+            timeStamping: true,
+        },
+        {
+            name: 'nsCertType',
+            client: true,
+            server: true,
+            email: true,
+            objsign: true,
+            sslCA: true,
+            emailCA: true,
+            objCA: true,
+        },
+        {
+            name: 'subjectAltName',
+            altNames,
+        },
+        {
+            name: 'subjectKeyIdentifier',
+        },
+    ]);
+    cert.sign(keys.privateKey, node_forge_1.default.md.sha256.create());
+    const privPem = pki.privateKeyToPem(keys.privateKey);
+    const certPem = pki.certificateToPem(cert);
+    await fs.mkdirp(certDirectory);
+    await fs.writeFile(privateKeyPath, privPem);
+    await fs.writeFile(certPath, certPem);
+    return {
+        key: privPem,
+        cert: certPem,
+    };
+}

package/dist/getCertificate.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getCertificate;
+async function getCertificate(fs, options) {
+    try {
+        let cert = await fs.readFile(options.cert);
+        let key = await fs.readFile(options.key);
+        return { key, cert };
+    }
+    catch (err) {
+        throw new Error('Certificate and/or key not found');
+    }
+}

package/dist/getExisting.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 = getExisting;
+const fs_1 = __importDefault(require("fs"));
+/**
+ * Creates an object that contains both source and minified (using the source as a fallback).
+ * e.g. builtins.min.js and builtins.js.
+ */
+function getExisting(minifiedPath, sourcePath) {
+    let source = fs_1.default.readFileSync(sourcePath, 'utf8').trim();
+    return {
+        source,
+        minified: fs_1.default.existsSync(minifiedPath)
+            ? fs_1.default.readFileSync(minifiedPath, 'utf8').trim().replace(/;$/, '')
+            : source,
+    };
+}

package/dist/getModuleParts.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getModuleParts;
+const path_1 = __importDefault(require("path"));
+const path_2 = require("./path");
+/**
+ * Returns the package name and the optional subpath
+ */
+function getModuleParts(_name) {
+    let name = path_1.default.normalize(_name);
+    let splitOn = name.indexOf(path_1.default.sep);
+    if (name.charAt(0) === '@') {
+        splitOn = name.indexOf(path_1.default.sep, splitOn + 1);
+    }
+    if (splitOn < 0) {
+        return [(0, path_2.normalizeSeparators)(name), undefined];
+    }
+    else {
+        return [
+            (0, path_2.normalizeSeparators)(name.substring(0, splitOn)),
+            name.substring(splitOn + 1) || undefined,
+        ];
+    }
+}