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

package/lib/Server.js

@@ -0,0 +1,466 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.SOURCES_ENDPOINT = void 0;
+exports.setHeaders = setHeaders;
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+  _assert = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _url() {
+  const data = _interopRequireWildcard(require("url"));
+  _url = function () {
+    return data;
+  };
+  return data;
+}
+function _utils() {
+  const data = require("@atlaspack/utils");
+  _utils = function () {
+    return data;
+  };
+  return data;
+}
+var _serverErrors = _interopRequireDefault(require("./serverErrors"));
+function _fs() {
+  const data = _interopRequireDefault(require("fs"));
+  _fs = function () {
+    return data;
+  };
+  return data;
+}
+function _ejs() {
+  const data = _interopRequireDefault(require("ejs"));
+  _ejs = function () {
+    return data;
+  };
+  return data;
+}
+function _connect() {
+  const data = _interopRequireDefault(require("connect"));
+  _connect = function () {
+    return data;
+  };
+  return data;
+}
+function _serveHandler() {
+  const data = _interopRequireDefault(require("serve-handler"));
+  _serveHandler = function () {
+    return data;
+  };
+  return data;
+}
+function _httpProxyMiddleware() {
+  const data = require("http-proxy-middleware");
+  _httpProxyMiddleware = function () {
+    return data;
+  };
+  return data;
+}
+function _launchEditor() {
+  const data = _interopRequireDefault(require("launch-editor"));
+  _launchEditor = function () {
+    return data;
+  };
+  return data;
+}
+function _fresh() {
+  const data = _interopRequireDefault(require("fresh"));
+  _fresh = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// @ts-expect-error TS2307
+
+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;
+const SOURCES_ENDPOINT = exports.SOURCES_ENDPOINT = '/__parcel_source_root';
+const EDITOR_ENDPOINT = '/__parcel_launch_editor';
+const TEMPLATE_404 = _fs().default.readFileSync(_path().default.join(__dirname, '..', 'templates/404.html'), 'utf8');
+const TEMPLATE_500 = _fs().default.readFileSync(_path().default.join(__dirname, '..', 'templates/500.html'), 'utf8');
+class Server {
+  constructor(options) {
+    this.options = options;
+    try {
+      this.rootPath = new (_url().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().prettyDiagnostic)(d, options);
+      return {
+        message: (0, _utils().ansiHtml)(ansiDiagnostic.message),
+        stack: ansiDiagnostic.stack ? (0, _utils().ansiHtml)(ansiDiagnostic.stack) : null,
+        frames: ansiDiagnostic.frames.map(f => ({
+          location: f.location,
+          code: (0, _utils().ansiHtml)(f.code)
+        })),
+        hints: ansiDiagnostic.hints.map(hint => (0, _utils().ansiHtml)(hint)),
+        documentation: d.documentationURL ?? ''
+      };
+    }));
+  }
+  respond(req, res) {
+    if (this.middleware.some(handler => handler(req, res))) return;
+    let {
+      pathname,
+      search
+    } = _url().default.parse(req.originalUrl || req.url);
+    if (pathname == null) {
+      pathname = '/';
+    }
+    if (pathname.startsWith(EDITOR_ENDPOINT) && search) {
+      let query = new (_url().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(SOURCES_ENDPOINT)) {
+          file = file.slice(SOURCES_ENDPOINT.length + 1);
+        }
+        (0, _launchEditor().default)(file);
+      }
+      res.end();
+    } else if (this.errors) {
+      return this.send500(req, res);
+    } else if (_path().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(SOURCES_ENDPOINT)) {
+      req.url = pathname.slice(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().default.posix.extname(bundle.name) === '.html').map(bundle => {
+        return `/${(0, _utils().relativePath)(this.options.distDir, bundle.filePath, false)}`;
+      });
+      let indexFilePath = null;
+      let {
+        pathname: reqURL
+      } = _url().default.parse(req.originalUrl || req.url);
+      if (!reqURL) {
+        reqURL = '/';
+      }
+      if (htmlBundleFilePaths.length === 1) {
+        indexFilePath = htmlBundleFilePaths[0];
+      } else {
+        var _bestMatch;
+        let bestMatch = null;
+        for (let bundle of htmlBundleFilePaths) {
+          let bundleDir = _path().default.posix.dirname(bundle);
+          let bundleDirSubdir = bundleDir === '/' ? bundleDir : bundleDir + '/';
+          let withoutExtension = _path().default.posix.basename(bundle, _path().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().default.posix.join(bundleDir, withoutExtension)) {
+            // bundle is /bar/foo.html and /bar/foo was requested
+            matchesIsIndex = false;
+          }
+          if (matchesIsIndex != null) {
+            var _bundle$match;
+            let depth = ((_bundle$match = bundle.match(SLASH_REGEX)) === null || _bundle$match === void 0 ? void 0 : _bundle$match.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 = bestMatch) === null || _bestMatch === void 0 ? void 0 : _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().default.parse(req.url);
+      if (!pathname) {
+        this.send500(req, res);
+        return;
+      }
+      let requestedPath = _path().default.normalize(pathname.slice(1));
+      let bundle = bundleGraph.getBundles().find(b => _path().default.relative(this.options.distDir, b.filePath) === requestedPath);
+      if (!bundle) {
+        this.serveDist(req, res, next);
+        return;
+      }
+      (0, _assert().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().default.parse(req.url).pathname || '';
+      filePath = decodeURIComponent(filePath);
+    } catch (err) {
+      return this.sendError(res, 400);
+    }
+    filePath = _path().default.normalize('.' + _path().default.sep + filePath);
+
+    // malicious path
+    if (filePath.includes(_path().default.sep + '..' + _path().default.sep)) {
+      return this.sendError(res, 403);
+    }
+
+    // join / normalize from the root dir
+    if (!_path().default.isAbsolute(filePath)) {
+      filePath = _path().default.normalize(_path().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().default)(req.headers, {
+      'last-modified': stat.mtime.toUTCString()
+    })) {
+      res.statusCode = 304;
+      res.end();
+      return;
+    }
+    return (0, _serveHandler().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().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().default.join(this.options.projectRoot, 'index');
+    const configFilePath = await (0, _utils().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().default.basename(configFilePath);
+    if (filename === '.proxyrc' || filename === '.proxyrc.json') {
+      let conf = await (0, _utils().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, _httpProxyMiddleware().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().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().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.default)(err, this.options.port)
+        });
+        reject(err);
+      });
+      server.once('listening', () => {
+        // @ts-expect-error TS2345
+        resolve(server);
+      });
+    });
+  }
+  async stop() {
+    (0, _assert().default)(this.stopServer != null);
+    await this.stopServer();
+    this.stopServer = null;
+  }
+}
+exports.default = Server;

package/lib/ServerDataProvider.js

@@ -0,0 +1 @@
+"use strict";