@atlaspack/utils 2.14.5-canary.36 → 2.14.5-canary.361

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

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,
+        ];
+    }
+}

package/dist/getRootDir.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getRootDir;
+const glob_1 = require("./glob");
+const path_1 = __importDefault(require("path"));
+function getRootDir(files) {
+    let cur = null;
+    for (let file of files) {
+        let parsed = path_1.default.parse(file);
+        parsed.dir = findGlobRoot(parsed.dir);
+        if (!cur) {
+            cur = parsed;
+        }
+        else if (parsed.root !== cur.root) {
+            // bail out. there is no common root.
+            // this can happen on windows, e.g. C:\foo\bar vs. D:\foo\bar
+            return process.cwd();
+        }
+        else {
+            // find the common path parts.
+            let curParts = cur.dir.split(path_1.default.sep);
+            let newParts = parsed.dir.split(path_1.default.sep);
+            let len = Math.min(curParts.length, newParts.length);
+            let i = 0;
+            while (i < len && curParts[i] === newParts[i]) {
+                i++;
+            }
+            cur.dir = i > 1 ? curParts.slice(0, i).join(path_1.default.sep) : cur.root;
+        }
+    }
+    return cur ? cur.dir : process.cwd();
+}
+// Transforms a path like `packages/*/src/index.js` to the root of the glob, `packages/`
+function findGlobRoot(dir) {
+    let parts = dir.split(path_1.default.sep);
+    let last = parts.length;
+    for (let i = parts.length - 1; i >= 0; i--) {
+        if ((0, glob_1.isGlob)(parts[i])) {
+            last = i;
+        }
+    }
+    return parts.slice(0, last).join(path_1.default.sep);
+}

package/dist/getTimeId.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getTimeId;
+function getTimeId() {
+    let now = new Date();
+    return (String(now.getFullYear()) +
+        String(now.getMonth() + 1).padStart(2, '0') +
+        String(now.getDate()).padStart(2, '0') +
+        '-' +
+        String(now.getHours()).padStart(2, '0') +
+        String(now.getMinutes()).padStart(2, '0') +
+        String(now.getSeconds()).padStart(2, '0'));
+}

package/dist/glob.js

@@ -0,0 +1,129 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isGlob = isGlob;
+exports.isGlobMatch = isGlobMatch;
+exports.globMatch = globMatch;
+exports.globToRegex = globToRegex;
+exports.globSync = globSync;
+exports.glob = glob;
+const is_glob_1 = __importDefault(require("is-glob"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const micromatch_1 = __importStar(require("micromatch"));
+const path_1 = require("./path");
+function isGlob(p) {
+    return (0, is_glob_1.default)((0, path_1.normalizeSeparators)(p));
+}
+function isGlobMatch(filePath, glob, opts) {
+    glob = Array.isArray(glob)
+        ? glob.map(path_1.normalizeSeparators)
+        : (0, path_1.normalizeSeparators)(glob);
+    return (0, micromatch_1.isMatch)(filePath, glob, opts);
+}
+function globMatch(values, glob, opts) {
+    glob = Array.isArray(glob)
+        ? glob.map(path_1.normalizeSeparators)
+        : (0, path_1.normalizeSeparators)(glob);
+    return (0, micromatch_1.default)(values, glob, opts);
+}
+function globToRegex(glob, opts) {
+    return (0, micromatch_1.makeRe)(glob, opts);
+}
+function globSync(p, fs, options) {
+    options = {
+        ...options,
+        fs: {
+            statSync: (p) => {
+                return fs.statSync(p);
+            },
+            lstatSync: (p) => {
+                // Our FileSystem interface doesn't have lstat support at the moment,
+                // but this is fine for our purposes since we follow symlinks by default.
+                return fs.statSync(p);
+            },
+            // @ts-expect-error TS7006
+            readdirSync: (p, opts) => {
+                return fs.readdirSync(p, opts);
+            },
+        },
+    };
+    return fast_glob_1.default.sync((0, path_1.normalizeSeparators)(p), options);
+}
+function glob(p, fs, options) {
+    options = {
+        ...options,
+        fs: {
+            stat: async (p, cb) => {
+                try {
+                    cb(null, await fs.stat(p));
+                }
+                catch (err) {
+                    // @ts-expect-error TS2345
+                    cb(err);
+                }
+            },
+            lstat: async (p, cb) => {
+                // Our FileSystem interface doesn't have lstat support at the moment,
+                // but this is fine for our purposes since we follow symlinks by default.
+                try {
+                    cb(null, await fs.stat(p));
+                }
+                catch (err) {
+                    // @ts-expect-error TS2345
+                    cb(err);
+                }
+            },
+            // @ts-expect-error TS7006
+            readdir: async (p, opts, cb) => {
+                if (typeof opts === 'function') {
+                    cb = opts;
+                    // @ts-expect-error TS2322
+                    opts = null;
+                }
+                try {
+                    cb(null, await fs.readdir(p, opts));
+                }
+                catch (err) {
+                    // @ts-expect-error TS2345
+                    cb(err);
+                }
+            },
+        },
+    };
+    return (0, fast_glob_1.default)((0, path_1.normalizeSeparators)(p), options);
+}

package/dist/hash.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashStream = hashStream;
+exports.hashObject = hashObject;
+exports.hashFile = hashFile;
+const collection_1 = require("./collection");
+const rust_1 = require("@atlaspack/rust");
+function hashStream(stream) {
+    let hash = new rust_1.Hash();
+    return new Promise((resolve, reject) => {
+        stream.on('error', (err) => {
+            reject(err);
+        });
+        stream
+            .on('data', (chunk) => {
+            hash.writeBuffer(chunk);
+        })
+            .on('end', function () {
+            resolve(hash.finish());
+        })
+            .on('error', (err) => {
+            reject(err);
+        });
+    });
+}
+function hashObject(obj) {
+    return (0, rust_1.hashString)(JSON.stringify((0, collection_1.objectSortedEntriesDeep)(obj)));
+}
+let testCache = {
+/*:: ...null */
+};
+function hashFile(fs, filePath) {
+    if (process.env.ATLASPACK_BUILD_ENV === 'test') {
+        // Development builds of these native modules are especially big and slow to hash.
+        if (/parcel-swc\.[^\\/]+\.node$|lightningcss.[^\\/]+.node$/.test(filePath)) {
+            let cacheEntry = testCache[filePath];
+            if (cacheEntry)
+                return cacheEntry;
+            let v = hashStream(fs.createReadStream(filePath));
+            testCache[filePath] = v;
+            return v;
+        }
+    }
+    return hashStream(fs.createReadStream(filePath));
+}

package/dist/http-server.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHTTPServer = createHTTPServer;
+const http_1 = __importDefault(require("http"));
+const https_1 = __importDefault(require("https"));
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const _1 = require("./");
+// Creates either an http or https server with an awaitable dispose
+// that closes any connections
+async function createHTTPServer(options) {
+    let server;
+    if (!options.https) {
+        server = http_1.default.createServer(options.listener);
+    }
+    else if (options.https === true) {
+        let { cert, key } = await (0, _1.generateCertificate)(options.outputFS, options.cacheDir, options.host);
+        server = https_1.default.createServer({ cert, key }, options.listener);
+    }
+    else {
+        let { cert, key } = await (0, _1.getCertificate)(options.inputFS, options.https);
+        server = https_1.default.createServer({ cert, key }, options.listener);
+    }
+    // HTTPServer#close only stops accepting new connections, and does not close existing ones.
+    // Before closing, destroy any active connections through their sockets. Additionally, remove sockets when they close:
+    // https://stackoverflow.com/questions/18874689/force-close-all-connections-in-a-node-js-http-server
+    // https://stackoverflow.com/questions/14626636/how-do-i-shutdown-a-node-js-https-server-immediately/14636625#14636625
+    let sockets = new Set();
+    server.on('connection', (socket) => {
+        (0, nullthrows_1.default)(sockets).add(socket);
+        socket.on('close', () => {
+            (0, nullthrows_1.default)(sockets).delete(socket);
+        });
+    });
+    return {
+        server,
+        stop() {
+            return new Promise((resolve, reject) => {
+                for (let socket of (0, nullthrows_1.default)(sockets)) {
+                    socket.destroy();
+                }
+                sockets = new Set();
+                server.close((err) => {
+                    if (err != null) {
+                        reject(err);
+                        return;
+                    }
+                    resolve();
+                });
+            });
+        },
+    };
+}