@atlaspack/reporter-dev-server 2.14.5-canary.49 → 2.14.5-canary.491

package/dist/HMRServer.js

@@ -0,0 +1,220 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Server_1 = require("./Server");
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const url_1 = __importDefault(require("url"));
+// @ts-expect-error TS7016
+const mime_types_1 = __importDefault(require("mime-types"));
+// @ts-expect-error TS7016
+const ws_1 = __importDefault(require("ws"));
+const assert_1 = __importDefault(require("assert"));
+const utils_1 = require("@atlaspack/utils");
+const FS_CONCURRENCY = 64;
+const HMR_ENDPOINT = '/__parcel_hmr';
+const BROADCAST_MAX_ASSETS = 10000;
+class HMRServer {
+    constructor(options) {
+        this.unresolvedError = null;
+        this.bundleGraph = null;
+        this.options = options;
+    }
+    async start() {
+        let server = this.options.devServer;
+        if (!server) {
+            let result = await (0, utils_1.createHTTPServer)({
+                https: this.options.https,
+                inputFS: this.options.inputFS,
+                outputFS: this.options.outputFS,
+                cacheDir: this.options.cacheDir,
+                listener: (req, res) => {
+                    (0, Server_1.setHeaders)(res);
+                    if (!this.handle(req, res)) {
+                        res.statusCode = 404;
+                        res.end();
+                    }
+                },
+            });
+            server = result.server;
+            server.listen(this.options.port, this.options.host);
+            this.stopServer = result.stop;
+        }
+        else {
+            this.options.addMiddleware?.((req, res) => this.handle(req, res));
+        }
+        this.wss = new ws_1.default.Server({ server });
+        this.wss.on('connection', (ws) => {
+            if (this.unresolvedError) {
+                ws.send(JSON.stringify(this.unresolvedError));
+            }
+        });
+        this.wss.on('error', (err) => this.handleSocketError(err));
+    }
+    handle(req, res) {
+        let { pathname } = url_1.default.parse(req.originalUrl || req.url);
+        if (pathname != null && pathname.startsWith(HMR_ENDPOINT)) {
+            let id = pathname.slice(HMR_ENDPOINT.length + 1);
+            let bundleGraph = (0, nullthrows_1.default)(this.bundleGraph);
+            let asset = bundleGraph.getAssetById(id);
+            this.getHotAssetContents(asset).then((output) => {
+                res.setHeader('Content-Type', mime_types_1.default.contentType(asset.type));
+                res.end(output);
+            });
+            return true;
+        }
+        return false;
+    }
+    async stop() {
+        if (this.stopServer != null) {
+            await this.stopServer();
+            this.stopServer = null;
+        }
+        this.wss.close();
+    }
+    async emitError(options, diagnostics) {
+        let renderedDiagnostics = await Promise.all(diagnostics.map((d) => (0, utils_1.prettyDiagnostic)(d, options)));
+        // store the most recent error so we can notify new connections
+        // and so we can broadcast when the error is resolved
+        this.unresolvedError = {
+            type: 'error',
+            diagnostics: {
+                ansi: renderedDiagnostics,
+                html: renderedDiagnostics.map((d, i) => {
+                    return {
+                        message: (0, utils_1.ansiHtml)(d.message),
+                        stack: (0, utils_1.ansiHtml)(d.stack),
+                        frames: d.frames.map((f) => ({
+                            location: f.location,
+                            code: (0, utils_1.ansiHtml)(f.code),
+                        })),
+                        hints: d.hints.map((hint) => (0, utils_1.ansiHtml)(hint)),
+                        documentation: diagnostics[i].documentationURL ?? '',
+                    };
+                }),
+            },
+        };
+        this.broadcast(this.unresolvedError);
+    }
+    async emitUpdate(event) {
+        this.unresolvedError = null;
+        this.bundleGraph = event.bundleGraph;
+        let changedAssets = new Set(event.changedAssets.values());
+        if (changedAssets.size === 0)
+            return;
+        let queue = new utils_1.PromiseQueue({ maxConcurrent: FS_CONCURRENCY });
+        for (let asset of changedAssets) {
+            if (asset.type !== 'js' && asset.type !== 'css') {
+                // If all of the incoming dependencies of the asset actually resolve to a JS asset
+                // rather than the original, we can mark the runtimes as changed instead. URL runtimes
+                // have a cache busting query param added with HMR enabled which will trigger a reload.
+                let runtimes = new Set();
+                let incomingDeps = event.bundleGraph.getIncomingDependencies(asset);
+                let isOnlyReferencedByRuntimes = incomingDeps.every((dep) => {
+                    let resolved = event.bundleGraph.getResolvedAsset(dep);
+                    let isRuntime = resolved?.type === 'js' && resolved !== asset;
+                    if (resolved && isRuntime) {
+                        runtimes.add(resolved);
+                    }
+                    return isRuntime;
+                });
+                if (isOnlyReferencedByRuntimes) {
+                    for (let runtime of runtimes) {
+                        // @ts-expect-error TS2345
+                        changedAssets.add(runtime);
+                    }
+                    continue;
+                }
+            }
+            queue.add(async () => {
+                let dependencies = event.bundleGraph.getDependencies(asset);
+                let depsByBundle = {};
+                for (let bundle of event.bundleGraph.getBundlesWithAsset(asset)) {
+                    let deps = {};
+                    for (let dep of dependencies) {
+                        let resolved = event.bundleGraph.getResolvedAsset(dep, bundle);
+                        if (resolved) {
+                            deps[getSpecifier(dep)] =
+                                event.bundleGraph.getAssetPublicId(resolved);
+                        }
+                    }
+                    depsByBundle[bundle.id] = deps;
+                }
+                return {
+                    id: event.bundleGraph.getAssetPublicId(asset),
+                    url: this.getSourceURL(asset),
+                    type: asset.type,
+                    // No need to send the contents of non-JS assets to the client.
+                    output: asset.type === 'js' ? await this.getHotAssetContents(asset) : '',
+                    envHash: asset.env.id,
+                    outputFormat: asset.env.outputFormat,
+                    depsByBundle,
+                };
+            });
+        }
+        let assets = await queue.run();
+        if (assets.length >= BROADCAST_MAX_ASSETS) {
+            // Too many assets to send via an update without errors, just reload instead
+            this.broadcast({ type: 'reload' });
+        }
+        else {
+            this.broadcast({
+                type: 'update',
+                // @ts-expect-error TS2322
+                assets,
+            });
+        }
+    }
+    async getHotAssetContents(asset) {
+        let output = await asset.getCode();
+        let bundleGraph = (0, nullthrows_1.default)(this.bundleGraph);
+        if (asset.type === 'js') {
+            let publicId = bundleGraph.getAssetPublicId(asset);
+            output = `parcelHotUpdate['${publicId}'] = function (require, module, exports) {${output}}`;
+        }
+        let sourcemap = await asset.getMap();
+        if (sourcemap) {
+            let sourcemapStringified = await sourcemap.stringify({
+                format: 'inline',
+                sourceRoot: Server_1.SOURCES_ENDPOINT + '/',
+                fs: asset.fs,
+            });
+            (0, assert_1.default)(typeof sourcemapStringified === 'string');
+            output += `\n//# sourceMappingURL=${sourcemapStringified}`;
+            output += `\n//# sourceURL=${encodeURI(this.getSourceURL(asset))}\n`;
+        }
+        return output;
+    }
+    getSourceURL(asset) {
+        let origin = '';
+        if (!this.options.devServer) {
+            origin = `http://${this.options.host || 'localhost'}:${this.options.port}`;
+        }
+        return origin + HMR_ENDPOINT + '/' + asset.id;
+    }
+    handleSocketError(err) {
+        if (err.code === 'ECONNRESET') {
+            // This gets triggered on page refresh, ignore this
+            return;
+        }
+        this.options.logger.warn({
+            origin: '@atlaspack/reporter-dev-server',
+            message: `[${err.code}]: ${err.message}`,
+            stack: err.stack,
+        });
+    }
+    broadcast(msg) {
+        const json = JSON.stringify(msg);
+        for (let ws of this.wss.clients) {
+            ws.send(json);
+        }
+    }
+}
+exports.default = HMRServer;
+function getSpecifier(dep) {
+    if (typeof dep.meta.placeholder === 'string') {
+        return dep.meta.placeholder;
+    }
+    return dep.specifier;
+}

package/dist/Server.js

@@ -0,0 +1,408 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SOURCES_ENDPOINT = void 0;
+exports.setHeaders = setHeaders;
+const assert_1 = __importDefault(require("assert"));
+const path_1 = __importDefault(require("path"));
+const url_1 = __importDefault(require("url"));
+const utils_1 = require("@atlaspack/utils");
+const serverErrors_1 = __importDefault(require("./serverErrors"));
+const fs_1 = __importDefault(require("fs"));
+const ejs_1 = __importDefault(require("ejs"));
+const connect_1 = __importDefault(require("connect"));
+const serve_handler_1 = __importDefault(require("serve-handler"));
+const http_proxy_middleware_1 = require("http-proxy-middleware");
+const url_2 = require("url");
+const launch_editor_1 = __importDefault(require("launch-editor"));
+const fresh_1 = __importDefault(require("fresh"));
+function setHeaders(res) {
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, HEAD, PUT, PATCH, POST, DELETE');
+    res.setHeader('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept, Content-Type');
+    res.setHeader('Cache-Control', 'max-age=0, must-revalidate');
+}
+const SLASH_REGEX = /\//g;
+exports.SOURCES_ENDPOINT = '/__parcel_source_root';
+const EDITOR_ENDPOINT = '/__parcel_launch_editor';
+const TEMPLATE_404 = fs_1.default.readFileSync(path_1.default.join(__dirname, '..', 'templates/404.html'), 'utf8');
+const TEMPLATE_500 = fs_1.default.readFileSync(path_1.default.join(__dirname, '..', 'templates/500.html'), 'utf8');
+class Server {
+    constructor(options) {
+        this.options = options;
+        try {
+            this.rootPath = new url_2.URL(options.publicUrl).pathname;
+        }
+        catch (e) {
+            this.rootPath = options.publicUrl;
+        }
+        this.pending = true;
+        this.pendingRequests = [];
+        this.middleware = [];
+        this.bundleGraph = null;
+        this.requestBundle = null;
+        this.errors = null;
+    }
+    buildStart() {
+        this.pending = true;
+    }
+    buildSuccess(bundleGraph, requestBundle) {
+        this.bundleGraph = bundleGraph;
+        this.requestBundle = requestBundle;
+        this.errors = null;
+        this.pending = false;
+        if (this.pendingRequests.length > 0) {
+            let pendingRequests = this.pendingRequests;
+            this.pendingRequests = [];
+            for (let [req, res] of pendingRequests) {
+                this.respond(req, res);
+            }
+        }
+    }
+    async buildError(options, diagnostics) {
+        this.pending = false;
+        this.errors = await Promise.all(diagnostics.map(async (d) => {
+            let ansiDiagnostic = await (0, utils_1.prettyDiagnostic)(d, options);
+            return {
+                message: (0, utils_1.ansiHtml)(ansiDiagnostic.message),
+                stack: ansiDiagnostic.stack ? (0, utils_1.ansiHtml)(ansiDiagnostic.stack) : null,
+                frames: ansiDiagnostic.frames.map((f) => ({
+                    location: f.location,
+                    code: (0, utils_1.ansiHtml)(f.code),
+                })),
+                hints: ansiDiagnostic.hints.map((hint) => (0, utils_1.ansiHtml)(hint)),
+                documentation: d.documentationURL ?? '',
+            };
+        }));
+    }
+    respond(req, res) {
+        if (this.middleware.some((handler) => handler(req, res)))
+            return;
+        let { pathname, search } = url_1.default.parse(req.originalUrl || req.url);
+        if (pathname == null) {
+            pathname = '/';
+        }
+        if (pathname.startsWith(EDITOR_ENDPOINT) && search) {
+            let query = new url_2.URLSearchParams(search);
+            let file = query.get('file');
+            if (file) {
+                // File location might start with /__parcel_source_root if it came from a source map.
+                if (file.startsWith(exports.SOURCES_ENDPOINT)) {
+                    file = file.slice(exports.SOURCES_ENDPOINT.length + 1);
+                }
+                (0, launch_editor_1.default)(file);
+            }
+            res.end();
+        }
+        else if (this.errors) {
+            return this.send500(req, res);
+        }
+        else if (path_1.default.extname(pathname) === '') {
+            // If the URL doesn't start with the public path, or the URL doesn't
+            // have a file extension, send the main HTML bundle.
+            return this.sendIndex(req, res);
+        }
+        else if (pathname.startsWith(exports.SOURCES_ENDPOINT)) {
+            req.url = pathname.slice(exports.SOURCES_ENDPOINT.length);
+            return this.serve(this.options.inputFS, this.options.projectRoot, req, res, () => this.send404(req, res));
+        }
+        else if (pathname.startsWith(this.rootPath)) {
+            // Otherwise, serve the file from the dist folder
+            req.url =
+                this.rootPath === '/' ? pathname : pathname.slice(this.rootPath.length);
+            if (req.url[0] !== '/') {
+                req.url = '/' + req.url;
+            }
+            return this.serveBundle(req, res, () => this.sendIndex(req, res));
+        }
+        else {
+            return this.send404(req, res);
+        }
+    }
+    sendIndex(req, res) {
+        if (this.bundleGraph) {
+            // If the main asset is an HTML file, serve it
+            let htmlBundleFilePaths = this.bundleGraph
+                .getBundles()
+                .filter((bundle) => path_1.default.posix.extname(bundle.name) === '.html')
+                .map((bundle) => {
+                return `/${(0, utils_1.relativePath)(this.options.distDir, bundle.filePath, false)}`;
+            });
+            let indexFilePath = null;
+            let { pathname: reqURL } = url_1.default.parse(req.originalUrl || req.url);
+            if (!reqURL) {
+                reqURL = '/';
+            }
+            if (htmlBundleFilePaths.length === 1) {
+                indexFilePath = htmlBundleFilePaths[0];
+            }
+            else {
+                let bestMatch = null;
+                for (let bundle of htmlBundleFilePaths) {
+                    let bundleDir = path_1.default.posix.dirname(bundle);
+                    let bundleDirSubdir = bundleDir === '/' ? bundleDir : bundleDir + '/';
+                    let withoutExtension = path_1.default.posix.basename(bundle, path_1.default.posix.extname(bundle));
+                    let isIndex = withoutExtension === 'index';
+                    let matchesIsIndex = null;
+                    if (isIndex &&
+                        (reqURL.startsWith(bundleDirSubdir) || reqURL === bundleDir)) {
+                        // bundle is /bar/index.html and (/bar or something inside of /bar/** was requested was requested)
+                        matchesIsIndex = true;
+                    }
+                    else if (reqURL == path_1.default.posix.join(bundleDir, withoutExtension)) {
+                        // bundle is /bar/foo.html and /bar/foo was requested
+                        matchesIsIndex = false;
+                    }
+                    if (matchesIsIndex != null) {
+                        let depth = bundle.match(SLASH_REGEX)?.length ?? 0;
+                        if (bestMatch == null ||
+                            // This one is more specific (deeper)
+                            bestMatch.depth < depth ||
+                            // This one is just as deep, but the bundle name matches and not just index.html
+                            (bestMatch.depth === depth && bestMatch.isIndex)) {
+                            bestMatch = { bundle, depth, isIndex: matchesIsIndex };
+                        }
+                    }
+                }
+                indexFilePath = bestMatch?.['bundle'] ?? htmlBundleFilePaths[0];
+            }
+            if (indexFilePath) {
+                req.url = indexFilePath;
+                this.serveBundle(req, res, () => this.send404(req, res));
+            }
+            else {
+                this.send404(req, res);
+            }
+        }
+        else {
+            this.send404(req, res);
+        }
+    }
+    async serveBundle(req, res, next) {
+        let bundleGraph = this.bundleGraph;
+        if (bundleGraph) {
+            let { pathname } = url_1.default.parse(req.url);
+            if (!pathname) {
+                this.send500(req, res);
+                return;
+            }
+            let requestedPath = path_1.default.normalize(pathname.slice(1));
+            let bundle = bundleGraph
+                .getBundles()
+                .find((b) => path_1.default.relative(this.options.distDir, b.filePath) === requestedPath);
+            if (!bundle) {
+                this.serveDist(req, res, next);
+                return;
+            }
+            (0, assert_1.default)(this.requestBundle != null);
+            try {
+                await this.requestBundle(bundle);
+            }
+            catch (err) {
+                this.send500(req, res);
+                return;
+            }
+            this.serveDist(req, res, next);
+        }
+        else {
+            this.send404(req, res);
+        }
+    }
+    serveDist(req, res, next) {
+        return this.serve(this.options.outputFS, this.options.distDir, req, res, next);
+    }
+    async serve(fs, root, req, res, next) {
+        if (req.method !== 'GET' && req.method !== 'HEAD') {
+            // method not allowed
+            res.statusCode = 405;
+            res.setHeader('Allow', 'GET, HEAD');
+            res.setHeader('Content-Length', '0');
+            res.end();
+            return;
+        }
+        try {
+            var filePath = url_1.default.parse(req.url).pathname || '';
+            filePath = decodeURIComponent(filePath);
+        }
+        catch (err) {
+            return this.sendError(res, 400);
+        }
+        filePath = path_1.default.normalize('.' + path_1.default.sep + filePath);
+        // malicious path
+        if (filePath.includes(path_1.default.sep + '..' + path_1.default.sep)) {
+            return this.sendError(res, 403);
+        }
+        // join / normalize from the root dir
+        if (!path_1.default.isAbsolute(filePath)) {
+            filePath = path_1.default.normalize(path_1.default.join(root, filePath));
+        }
+        try {
+            var stat = await fs.stat(filePath);
+        }
+        catch (err) {
+            if (err.code === 'ENOENT') {
+                return next(req, res);
+            }
+            return this.sendError(res, 500);
+        }
+        // Fall back to next handler if not a file
+        if (!stat || !stat.isFile()) {
+            return next(req, res);
+        }
+        if ((0, fresh_1.default)(req.headers, { 'last-modified': stat.mtime.toUTCString() })) {
+            res.statusCode = 304;
+            res.end();
+            return;
+        }
+        return (0, serve_handler_1.default)(req, res, {
+            public: root,
+            cleanUrls: false,
+        }, {
+            // @ts-expect-error TS7006
+            lstat: (path) => fs.stat(path),
+            // @ts-expect-error TS7006
+            realpath: (path) => fs.realpath(path),
+            // @ts-expect-error TS7006
+            createReadStream: (path, options) => fs.createReadStream(path, options),
+            // @ts-expect-error TS7006
+            readdir: (path) => fs.readdir(path),
+        });
+    }
+    sendError(res, statusCode) {
+        res.statusCode = statusCode;
+        res.end();
+    }
+    send404(req, res) {
+        res.statusCode = 404;
+        res.end(TEMPLATE_404);
+    }
+    send500(req, res) {
+        res.setHeader('Content-Type', 'text/html; charset=utf-8');
+        res.writeHead(500);
+        if (this.errors) {
+            return res.end(ejs_1.default.render(TEMPLATE_500, {
+                errors: this.errors,
+                hmrOptions: this.options.hmrOptions,
+            }));
+        }
+    }
+    logAccessIfVerbose(req) {
+        this.options.logger.verbose({
+            message: `Request: ${req.headers.host}${req.originalUrl || req.url}`,
+        });
+    }
+    /**
+     * Load proxy table from package.json and apply them.
+     */
+    async applyProxyTable(app) {
+        // avoid skipping project root
+        const fileInRoot = path_1.default.join(this.options.projectRoot, 'index');
+        const configFilePath = await (0, utils_1.resolveConfig)(this.options.inputFS, fileInRoot, [
+            '.proxyrc.cts',
+            '.proxyrc.mts',
+            '.proxyrc.ts',
+            '.proxyrc.cjs',
+            '.proxyrc.mjs',
+            '.proxyrc.js',
+            '.proxyrc',
+            '.proxyrc.json',
+        ], this.options.projectRoot);
+        if (!configFilePath) {
+            return this;
+        }
+        const filename = path_1.default.basename(configFilePath);
+        if (filename === '.proxyrc' || filename === '.proxyrc.json') {
+            let conf = await (0, utils_1.readConfig)(this.options.inputFS, configFilePath);
+            if (!conf) {
+                return this;
+            }
+            let cfg = conf.config;
+            if (typeof cfg !== 'object') {
+                this.options.logger.warn({
+                    message: "Proxy table in '.proxyrc' should be of object type. Skipping...",
+                });
+                return this;
+            }
+            for (const [context, options] of Object.entries(cfg)) {
+                // each key is interpreted as context, and value as middleware options
+                // @ts-expect-error TS2345
+                app.use((0, http_proxy_middleware_1.createProxyMiddleware)(context, options));
+            }
+        }
+        else {
+            let cfg = await this.options.packageManager.require(configFilePath, fileInRoot);
+            if (Object.prototype.toString.call(cfg) === '[object Module]') {
+                cfg = cfg.default;
+            }
+            if (typeof cfg !== 'function') {
+                this.options.logger.warn({
+                    message: `Proxy configuration file '${filename}' should export a function. Skipping...`,
+                });
+                return this;
+            }
+            cfg(app);
+        }
+        return this;
+    }
+    async start() {
+        const finalHandler = (req, res) => {
+            this.logAccessIfVerbose(req);
+            // Wait for the parcelInstance to finish bundling if needed
+            if (this.pending) {
+                this.pendingRequests.push([req, res]);
+            }
+            else {
+                this.respond(req, res);
+            }
+        };
+        const app = (0, connect_1.default)();
+        app.use((req, res, next) => {
+            setHeaders(res);
+            next();
+        });
+        app.use((req, res, next) => {
+            if (req.url === '/__parcel_healthcheck') {
+                res.statusCode = 200;
+                res.write(`${Date.now()}`);
+                res.end();
+            }
+            else {
+                next();
+            }
+        });
+        await this.applyProxyTable(app);
+        app.use(finalHandler);
+        let { server, stop } = await (0, utils_1.createHTTPServer)({
+            cacheDir: this.options.cacheDir,
+            https: this.options.https,
+            inputFS: this.options.inputFS,
+            listener: app,
+            outputFS: this.options.outputFS,
+            host: this.options.host,
+        });
+        this.stopServer = stop;
+        server.listen(this.options.port, this.options.host);
+        // @ts-expect-error TS2322
+        return new Promise((resolve, reject) => {
+            server.once('error', (err) => {
+                this.options.logger.error({
+                    // @ts-expect-error TS2345
+                    message: (0, serverErrors_1.default)(err, this.options.port),
+                });
+                reject(err);
+            });
+            server.once('listening', () => {
+                // @ts-expect-error TS2345
+                resolve(server);
+            });
+        });
+    }
+    async stop() {
+        (0, assert_1.default)(this.stopServer != null);
+        await this.stopServer();
+        this.stopServer = null;
+    }
+}
+exports.default = Server;

package/dist/ServerDataProvider.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });