@rsbuild/core 0.0.17 → 0.0.19

package/dist/server/devServer.js

@@ -0,0 +1,235 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var devServer_exports = {};
+__export(devServer_exports, {
+  RsbuildDevServer: () => RsbuildDevServer,
+  startDevServer: () => startDevServer
+});
+module.exports = __toCommonJS(devServer_exports);
+var import_http = require("http");
+var import_https = require("https");
+var import_url = __toESM(require("url"));
+var import_shared = require("@rsbuild/shared");
+var import_constants = require("./constants");
+var import_dev_middleware = __toESM(require("./dev-middleware"));
+var import_deepmerge = require("@rsbuild/shared/deepmerge");
+var import_connect = __toESM(require("connect"));
+var import_proxy = require("./proxy");
+var import_middlewares = require("./middlewares");
+class RsbuildDevServer {
+  constructor(options) {
+    this.middlewares = (0, import_connect.default)();
+    this.pwd = options.pwd;
+    this.dev = this.getDevOptions(options);
+    this.devMiddleware = new import_dev_middleware.default({
+      dev: this.dev,
+      devMiddleware: options.devMiddleware
+    });
+  }
+  getDevOptions(options) {
+    const devOptions = typeof options.dev === "boolean" ? {} : options.dev;
+    const defaultOptions = (0, import_constants.getDefaultDevOptions)();
+    return (0, import_deepmerge.deepmerge)(defaultOptions, devOptions);
+  }
+  applySetupMiddlewares() {
+    const setupMiddlewares = this.dev.setupMiddlewares || [];
+    const serverOptions = {
+      sockWrite: (type, data) => this.devMiddleware.sockWrite(type, data)
+    };
+    const before = [];
+    const after = [];
+    setupMiddlewares.forEach((handler) => {
+      handler(
+        {
+          unshift: (...handlers) => before.unshift(...handlers),
+          push: (...handlers) => after.push(...handlers)
+        },
+        serverOptions
+      );
+    });
+    return { before, after };
+  }
+  // Complete the preparation of services
+  async onInit(app) {
+    this.app = app;
+    const { before, after } = this.applySetupMiddlewares();
+    before.forEach((fn) => this.middlewares.use(fn));
+    await this.applyDefaultMiddlewares(app);
+    after.forEach((fn) => this.middlewares.use(fn));
+  }
+  async applyDefaultMiddlewares(app) {
+    const { dev, devMiddleware } = this;
+    if (dev.compress) {
+      const { default: compression } = await Promise.resolve().then(() => __toESM(require("http-compression")));
+      this.middlewares.use((req, res, next) => {
+        compression({
+          gzip: true,
+          brotli: false
+        })(req, res, next);
+      });
+    }
+    this.middlewares.use((req, res, next) => {
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      const path = req.url ? import_url.default.parse(req.url).pathname : "";
+      if (path == null ? void 0 : path.includes("hot-update")) {
+        res.setHeader("Access-Control-Allow-Credentials", "false");
+      }
+      const confHeaders = dev.headers;
+      if (confHeaders) {
+        for (const [key, value] of Object.entries(confHeaders)) {
+          res.setHeader(key, value);
+        }
+      }
+      next();
+    });
+    if (dev.proxy) {
+      const { middlewares, handleUpgrade } = (0, import_proxy.createProxyMiddleware)(dev.proxy);
+      app && handleUpgrade(app);
+      middlewares.forEach((middleware) => {
+        this.middlewares.use(middleware);
+      });
+    }
+    devMiddleware.init(app);
+    devMiddleware.middleware && this.middlewares.use(devMiddleware.middleware);
+    if (dev.historyApiFallback) {
+      const { default: connectHistoryApiFallback } = await Promise.resolve().then(() => __toESM(require("connect-history-api-fallback")));
+      const historyApiFallbackMiddleware = connectHistoryApiFallback(
+        // @ts-expect-error
+        typeof dev.historyApiFallback === "boolean" ? {} : dev.historyApiFallback
+      );
+      this.middlewares.use(historyApiFallbackMiddleware);
+      devMiddleware.middleware && this.middlewares.use(devMiddleware.middleware);
+    }
+    this.middlewares.use(import_middlewares.faviconFallbackMiddleware);
+  }
+  async createHTTPServer() {
+    const { dev } = this;
+    const devHttpsOption = typeof dev === "object" && dev.https;
+    if (devHttpsOption) {
+      const { genHttpsOptions } = require("./https");
+      const httpsOptions = await genHttpsOptions(devHttpsOption, this.pwd);
+      return (0, import_https.createServer)(httpsOptions, this.middlewares);
+    } else {
+      return (0, import_http.createServer)(this.middlewares);
+    }
+  }
+  listen(options, listener) {
+    const callback = () => {
+      listener == null ? void 0 : listener();
+    };
+    if (typeof options === "object") {
+      this.app.listen(options, callback);
+    } else {
+      this.app.listen(options || 8080, callback);
+    }
+  }
+  close() {
+    this.app.close();
+  }
+}
+async function startDevServer(options, startDevCompile, {
+  open,
+  compiler,
+  printURLs = true,
+  strictPort = false,
+  serverOptions = {},
+  logger: customLogger,
+  getPortSilently
+} = {}) {
+  var _a;
+  if (!process.env.NODE_ENV) {
+    process.env.NODE_ENV = "development";
+  }
+  const rsbuildConfig = options.context.config;
+  const logger = customLogger != null ? customLogger : import_shared.logger;
+  const { devServerConfig, port, host, https } = await (0, import_shared.getDevOptions)({
+    rsbuildConfig,
+    serverOptions,
+    strictPort,
+    getPortSilently
+  });
+  options.context.devServer = {
+    hostname: host,
+    port,
+    https,
+    open
+  };
+  const protocol = https ? "https" : "http";
+  let urls = (0, import_shared.getAddressUrls)(protocol, port, (_a = rsbuildConfig.dev) == null ? void 0 : _a.host);
+  if (printURLs) {
+    if ((0, import_shared.isFunction)(printURLs)) {
+      urls = printURLs(urls);
+      if (!Array.isArray(urls)) {
+        throw new Error("Please return an array in the `printURLs` function.");
+      }
+    }
+    (0, import_shared.printServerURLs)(urls, logger);
+  }
+  (0, import_shared.debug)("create dev server");
+  const devMiddleware = await startDevCompile(options, compiler);
+  const server = new RsbuildDevServer({
+    pwd: options.context.rootPath,
+    devMiddleware,
+    dev: devServerConfig
+  });
+  (0, import_shared.debug)("create dev server done");
+  await options.context.hooks.onBeforeStartDevServerHook.call();
+  const httpServer = await server.createHTTPServer();
+  await server.onInit(httpServer);
+  (0, import_shared.debug)("listen dev server");
+  return new Promise((resolve) => {
+    server.listen(
+      {
+        host,
+        port
+      },
+      async (err) => {
+        if (err) {
+          throw err;
+        }
+        (0, import_shared.debug)("listen dev server done");
+        await options.context.hooks.onAfterStartDevServerHook.call({ port });
+        resolve({
+          port,
+          urls: urls.map((item) => item.url),
+          server: {
+            close: () => {
+              server.close();
+            }
+          }
+        });
+      }
+    );
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RsbuildDevServer,
+  startDevServer
+});

package/dist/server/https.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+import { type DevServerHttpsOptions } from '@rsbuild/shared';
+export declare const genHttpsOptions: (userOptions: DevServerHttpsOptions, pwd: string) => Promise<{
+  key?: Buffer | string;
+  cert?: Buffer | string;
+}>;

package/dist/server/https.js

@@ -0,0 +1,50 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var https_exports = {};
+__export(https_exports, {
+  genHttpsOptions: () => genHttpsOptions
+});
+module.exports = __toCommonJS(https_exports);
+var import_shared = require("@rsbuild/shared");
+const genHttpsOptions = async (userOptions, pwd) => {
+  const httpsOptions = typeof userOptions === "boolean" ? {} : userOptions;
+  if (!httpsOptions.key || !httpsOptions.cert) {
+    let devcertPath;
+    try {
+      devcertPath = require.resolve("devcert", { paths: [pwd, __dirname] });
+    } catch (err) {
+      const command = import_shared.color.bold(import_shared.color.yellow(`npm add devcert@1.2.2 -D`));
+      import_shared.logger.error(
+        `You have enabled "dev.https" option, but the "devcert" package is not installed.`
+      );
+      import_shared.logger.error(
+        `Please run ${command} to install manually, otherwise the https can not work.`
+      );
+      throw new Error('[https] "devcert" is not found.');
+    }
+    const devcert = require(devcertPath);
+    const selfsign = await devcert.certificateFor(["localhost"]);
+    return selfsign;
+  }
+  return httpsOptions;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  genHttpsOptions
+});

package/dist/server/index.d.ts

@@ -0,0 +1,2 @@
+export { startDevServer } from './devServer';
+export { startProdServer } from './prodServer';

package/dist/server/index.js

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var server_exports = {};
+__export(server_exports, {
+  startDevServer: () => import_devServer.startDevServer,
+  startProdServer: () => import_prodServer.startProdServer
+});
+module.exports = __toCommonJS(server_exports);
+var import_devServer = require("./devServer");
+var import_prodServer = require("./prodServer");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  startDevServer,
+  startProdServer
+});

package/dist/server/middlewares.d.ts

@@ -0,0 +1,2 @@
+import { RequestHandler as Middleware } from '@rsbuild/shared';
+export declare const faviconFallbackMiddleware: Middleware;

package/dist/server/middlewares.js

@@ -0,0 +1,35 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var middlewares_exports = {};
+__export(middlewares_exports, {
+  faviconFallbackMiddleware: () => faviconFallbackMiddleware
+});
+module.exports = __toCommonJS(middlewares_exports);
+const faviconFallbackMiddleware = (req, res, next) => {
+  if (req.url === "/favicon.ico") {
+    res.statusCode = 204;
+    res.end();
+  } else {
+    next();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  faviconFallbackMiddleware
+});

package/dist/server/prodServer.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type { ListenOptions } from 'net';
+import { Server } from 'http';
+import connect from 'connect';
+import { Context, RsbuildConfig, StartServerResult } from '@rsbuild/shared';
+type RsbuildProdServerOptions = {
+  pwd: string;
+  output: {
+    path: string;
+    assetPrefix?: string;
+  };
+};
+export declare class RsbuildProdServer {
+  private app;
+  private options;
+  middlewares: connect.Server;
+  constructor(options: RsbuildProdServerOptions);
+  onInit(app: Server): Promise<void>;
+  private applyDefaultMiddlewares;
+  private applyStaticAssetMiddleware;
+  createHTTPServer(): Promise<Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>>;
+  listen(options?: number | ListenOptions | undefined, listener?: () => void): void;
+  close(): void;
+}
+export declare function startProdServer(context: Context, rsbuildConfig: RsbuildConfig): Promise<StartServerResult>;
+export {};

package/dist/server/prodServer.js

@@ -0,0 +1,136 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var prodServer_exports = {};
+__export(prodServer_exports, {
+  RsbuildProdServer: () => RsbuildProdServer,
+  startProdServer: () => startProdServer
+});
+module.exports = __toCommonJS(prodServer_exports);
+var import_http = require("http");
+var import_connect = __toESM(require("connect"));
+var import_path = require("path");
+var import_sirv = __toESM(require("sirv"));
+var import_shared = require("@rsbuild/shared");
+var import_middlewares = require("./middlewares");
+class RsbuildProdServer {
+  constructor(options) {
+    this.middlewares = (0, import_connect.default)();
+    this.options = options;
+  }
+  // Complete the preparation of services
+  async onInit(app) {
+    this.app = app;
+    await this.applyDefaultMiddlewares();
+  }
+  async applyDefaultMiddlewares() {
+    this.applyStaticAssetMiddleware();
+    this.middlewares.use(import_middlewares.faviconFallbackMiddleware);
+  }
+  applyStaticAssetMiddleware() {
+    const {
+      output: { path, assetPrefix },
+      pwd
+    } = this.options;
+    const assetMiddleware = (0, import_sirv.default)((0, import_path.join)(pwd, path), {
+      etag: true,
+      dev: true,
+      ignores: false
+    });
+    this.middlewares.use((req, res, next) => {
+      const url = req.url;
+      if (assetPrefix && (url == null ? void 0 : url.startsWith(assetPrefix))) {
+        req.url = url.slice(assetPrefix.length);
+        assetMiddleware(req, res, (...args) => {
+          req.url = url;
+          next(...args);
+        });
+      } else {
+        assetMiddleware(req, res, next);
+      }
+    });
+  }
+  async createHTTPServer() {
+    return (0, import_http.createServer)(this.middlewares);
+  }
+  listen(options, listener) {
+    const callback = () => {
+      listener == null ? void 0 : listener();
+    };
+    if (typeof options === "object") {
+      this.app.listen(options, callback);
+    } else {
+      this.app.listen(options || 8080, callback);
+    }
+  }
+  close() {
+    this.app.close();
+  }
+}
+async function startProdServer(context, rsbuildConfig) {
+  var _a, _b, _c, _d;
+  if (!process.env.NODE_ENV) {
+    process.env.NODE_ENV = "production";
+  }
+  const port = await (0, import_shared.getPort)(((_a = rsbuildConfig.dev) == null ? void 0 : _a.port) || import_shared.DEFAULT_PORT);
+  const server = new RsbuildProdServer({
+    pwd: context.rootPath,
+    output: {
+      path: ((_c = (_b = rsbuildConfig.output) == null ? void 0 : _b.distPath) == null ? void 0 : _c.root) || import_shared.ROOT_DIST_DIR,
+      assetPrefix: (_d = rsbuildConfig.output) == null ? void 0 : _d.assetPrefix
+    }
+  });
+  const httpServer = await server.createHTTPServer();
+  await server.onInit(httpServer);
+  return new Promise((resolve) => {
+    server.listen(
+      {
+        host: import_shared.DEFAULT_DEV_HOST,
+        port
+      },
+      () => {
+        const urls = (0, import_shared.getAddressUrls)("http", port);
+        (0, import_shared.printServerURLs)(urls);
+        resolve({
+          port,
+          urls: urls.map((item) => item.url),
+          server: {
+            close: () => {
+              server.close();
+            }
+          }
+        });
+      }
+    );
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RsbuildProdServer,
+  startProdServer
+});

package/dist/server/proxy.d.ts

@@ -0,0 +1,9 @@
+import http from 'http';
+import { RequestHandler } from 'http-proxy-middleware';
+import { ProxyDetail, RequestHandler as Middleware, RsbuildProxyOptions } from '@rsbuild/shared';
+export declare function formatProxyOptions(proxyOptions: RsbuildProxyOptions): ProxyDetail[];
+export type HttpUpgradeHandler = NonNullable<RequestHandler['upgrade']>;
+export declare const createProxyMiddleware: (proxyOptions: RsbuildProxyOptions) => {
+  middlewares: Middleware[];
+  handleUpgrade: (server: http.Server) => void;
+};

package/dist/server/proxy.js

@@ -0,0 +1,92 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var proxy_exports = {};
+__export(proxy_exports, {
+  createProxyMiddleware: () => createProxyMiddleware,
+  formatProxyOptions: () => formatProxyOptions
+});
+module.exports = __toCommonJS(proxy_exports);
+var import_http_proxy_middleware2 = require("http-proxy-middleware/dist/http-proxy-middleware");
+function formatProxyOptions(proxyOptions) {
+  var _a;
+  const ret = [];
+  if (Array.isArray(proxyOptions)) {
+    ret.push(...proxyOptions);
+  } else if ("target" in proxyOptions) {
+    ret.push(proxyOptions);
+  } else {
+    for (const [context, options] of Object.entries(proxyOptions)) {
+      const opts = {
+        context,
+        changeOrigin: true,
+        logLevel: "warn"
+      };
+      if (typeof options === "string") {
+        opts.target = options;
+      } else {
+        Object.assign(opts, options);
+      }
+      ret.push(opts);
+    }
+  }
+  const handleError = (err, _req, _res, _target) => {
+    console.error(err);
+  };
+  for (const opts of ret) {
+    (_a = opts.onError) != null ? _a : opts.onError = handleError;
+  }
+  return ret;
+}
+const createProxyMiddleware = (proxyOptions) => {
+  const formattedOptionsList = formatProxyOptions(proxyOptions);
+  const proxies = [];
+  const middlewares = [];
+  for (const opts of formattedOptionsList) {
+    const proxy = new import_http_proxy_middleware2.HttpProxyMiddleware(opts.context, opts);
+    const middleware = async (req, res, next) => {
+      const bypassUrl = typeof opts.bypass === "function" ? opts.bypass(req, res, opts) : null;
+      if (typeof bypassUrl === "boolean") {
+        res.statusCode = 404;
+        next();
+      } else if (typeof bypassUrl === "string") {
+        req.url = bypassUrl;
+        next();
+      } else {
+        proxy.middleware(req, res, next);
+      }
+    };
+    proxies.push(proxy);
+    middlewares.push(middleware);
+  }
+  const handleUpgrade = (server) => {
+    for (const proxy of proxies) {
+      const raw = proxy;
+      if (raw.proxyOptions.ws === true && !raw.wsInternalSubscribed) {
+        server.on("upgrade", raw.handleUpgrade);
+        raw.wsInternalSubscribed = true;
+      }
+    }
+  };
+  return { middlewares, handleUpgrade };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createProxyMiddleware,
+  formatProxyOptions
+});