@anansi/core 0.16.24 → 0.16.26

package/CHANGELOG.md

@@ -3,6 +3,18 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+### [0.16.26](https://github.com/ntucker/anansi/compare/@anansi/core@0.16.25...@anansi/core@0.16.26) (2023-04-04)
+
+### 📦 Package
+
+* Update webpack packages ([#1941](https://github.com/ntucker/anansi/issues/1941)) ([41e2df6](https://github.com/ntucker/anansi/commit/41e2df6fc0f475da703aee0a1e0c717c85283927))
+
+### [0.16.25](https://github.com/ntucker/anansi/compare/@anansi/core@0.16.24...@anansi/core@0.16.25) (2023-03-28)
+
+### 📦 Package
+
+* @ant-design/cssinjs ([230c1b1](https://github.com/ntucker/anansi/commit/230c1b1a1f47bd846023a64764ba479524211c5a))
+
 ### [0.16.24](https://github.com/ntucker/anansi/compare/@anansi/core@0.16.23...@anansi/core@0.16.24) (2023-03-27)
 
 **Note:** Version bump only for package @anansi/core

package/lib/scripts/floodSpouts.js

@@ -0,0 +1,11 @@
+import { hydrateRoot } from 'react-dom/client';
+export default async function floodSpouts(spouts, {
+  rootId = 'anansi-root'
+} = {}) {
+  var _document$getElementB;
+  const {
+    app
+  } = await spouts({});
+  hydrateRoot((_document$getElementB = document.getElementById(rootId)) != null ? _document$getElementB : document, app);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJoeWRyYXRlUm9vdCIsImZsb29kU3BvdXRzIiwic3BvdXRzIiwicm9vdElkIiwiX2RvY3VtZW50JGdldEVsZW1lbnRCIiwiYXBwIiwiZG9jdW1lbnQiLCJnZXRFbGVtZW50QnlJZCJdLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9mbG9vZFNwb3V0cy50c3giXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgaHlkcmF0ZVJvb3QgfSBmcm9tICdyZWFjdC1kb20vY2xpZW50JztcblxuZXhwb3J0IGRlZmF1bHQgYXN5bmMgZnVuY3Rpb24gZmxvb2RTcG91dHMoXG4gIHNwb3V0czogKHByb3BzOiBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPikgPT4gUHJvbWlzZTx7XG4gICAgYXBwOiBKU1guRWxlbWVudDtcbiAgfT4sXG4gIHsgcm9vdElkID0gJ2FuYW5zaS1yb290JyB9OiB7IHJvb3RJZD86IHN0cmluZyB9ID0ge30sXG4pIHtcbiAgY29uc3QgeyBhcHAgfSA9IGF3YWl0IHNwb3V0cyh7fSk7XG5cbiAgaHlkcmF0ZVJvb3QoZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQocm9vdElkKSA/PyBkb2N1bWVudCwgYXBwKTtcbn1cbiJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBU0EsV0FBVyxRQUFRLGtCQUFrQjtBQUU5QyxlQUFlLGVBQWVDLFdBQVdBLENBQ3ZDQyxNQUVFLEVBQ0Y7RUFBRUMsTUFBTSxHQUFHO0FBQW1DLENBQUMsR0FBRyxDQUFDLENBQUMsRUFDcEQ7RUFBQSxJQUFBQyxxQkFBQTtFQUNBLE1BQU07SUFBRUM7RUFBSSxDQUFDLEdBQUcsTUFBTUgsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDO0VBRWhDRixXQUFXLEVBQUFJLHFCQUFBLEdBQUNFLFFBQVEsQ0FBQ0MsY0FBYyxDQUFDSixNQUFNLENBQUMsWUFBQUMscUJBQUEsR0FBSUUsUUFBUSxFQUFFRCxHQUFHLENBQUM7QUFDL0QifQ==

package/lib/scripts/index.server.js

@@ -0,0 +1,10 @@
+export { default as laySpouts } from './laySpouts.js';
+export { default as documentSpout } from './spouts/document.server.js';
+export { default as restHooksSpout } from './spouts/restHooks.server.js';
+export { default as antdSpout } from './spouts/antd.server.js';
+export { default as routerSpout } from './spouts/router.server.js';
+export { default as prefetchSpout } from './spouts/prefetch.server.js';
+export { default as JSONSpout } from './spouts/json.server.js';
+export { default as appSpout } from './spouts/app.server.js';
+export * from './scripts/types.js';
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJkZWZhdWx0IiwibGF5U3BvdXRzIiwiZG9jdW1lbnRTcG91dCIsInJlc3RIb29rc1Nwb3V0IiwiYW50ZFNwb3V0Iiwicm91dGVyU3BvdXQiLCJwcmVmZXRjaFNwb3V0IiwiSlNPTlNwb3V0IiwiYXBwU3BvdXQiXSwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXguc2VydmVyLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IGRlZmF1bHQgYXMgbGF5U3BvdXRzIH0gZnJvbSAnLi9sYXlTcG91dHMuanMnO1xuZXhwb3J0IHsgZGVmYXVsdCBhcyBkb2N1bWVudFNwb3V0IH0gZnJvbSAnLi9zcG91dHMvZG9jdW1lbnQuc2VydmVyLmpzJztcbmV4cG9ydCB7IGRlZmF1bHQgYXMgcmVzdEhvb2tzU3BvdXQgfSBmcm9tICcuL3Nwb3V0cy9yZXN0SG9va3Muc2VydmVyLmpzJztcbmV4cG9ydCB7IGRlZmF1bHQgYXMgYW50ZFNwb3V0IH0gZnJvbSAnLi9zcG91dHMvYW50ZC5zZXJ2ZXIuanMnO1xuZXhwb3J0IHsgZGVmYXVsdCBhcyByb3V0ZXJTcG91dCB9IGZyb20gJy4vc3BvdXRzL3JvdXRlci5zZXJ2ZXIuanMnO1xuZXhwb3J0IHsgZGVmYXVsdCBhcyBwcmVmZXRjaFNwb3V0IH0gZnJvbSAnLi9zcG91dHMvcHJlZmV0Y2guc2VydmVyLmpzJztcbmV4cG9ydCB7IGRlZmF1bHQgYXMgSlNPTlNwb3V0IH0gZnJvbSAnLi9zcG91dHMvanNvbi5zZXJ2ZXIuanMnO1xuZXhwb3J0IHsgZGVmYXVsdCBhcyBhcHBTcG91dCB9IGZyb20gJy4vc3BvdXRzL2FwcC5zZXJ2ZXIuanMnO1xuZXhwb3J0IHR5cGUgeyBTZXJ2ZXJQcm9wcyB9IGZyb20gJy4vc3BvdXRzL3R5cGVzLmpzJztcbmV4cG9ydCB0eXBlIHsgU2VydmVyU3BvdXQgYXMgU3BvdXQgfSBmcm9tICcuL3Nwb3V0cy90eXBlcy5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3NjcmlwdHMvdHlwZXMuanMnO1xuIl0sIm1hcHBpbmdzIjoiQUFBQSxTQUFTQSxPQUFPLElBQUlDLFNBQVMsUUFBUSxnQkFBZ0I7QUFDckQsU0FBU0QsT0FBTyxJQUFJRSxhQUFhLFFBQVEsNkJBQTZCO0FBQ3RFLFNBQVNGLE9BQU8sSUFBSUcsY0FBYyxRQUFRLDhCQUE4QjtBQUN4RSxTQUFTSCxPQUFPLElBQUlJLFNBQVMsUUFBUSx5QkFBeUI7QUFDOUQsU0FBU0osT0FBTyxJQUFJSyxXQUFXLFFBQVEsMkJBQTJCO0FBQ2xFLFNBQVNMLE9BQU8sSUFBSU0sYUFBYSxRQUFRLDZCQUE2QjtBQUN0RSxTQUFTTixPQUFPLElBQUlPLFNBQVMsUUFBUSx5QkFBeUI7QUFDOUQsU0FBU1AsT0FBTyxJQUFJUSxRQUFRLFFBQVEsd0JBQXdCO0FBRzVELGNBQWMsb0JBQW9CIn0=

package/lib/scripts/laySpouts.js

@@ -0,0 +1,55 @@
+import crypto from 'crypto';
+import { renderToPipeableStream as reactRender } from 'react-dom/server';
+export default function laySpouts(spouts, {
+  timeoutMS = 10000,
+  onError
+} = {}) {
+  const render = async (clientManifest, req, res) => {
+    const nonce = crypto.randomBytes(16).toString('base64');
+    try {
+      const {
+        app
+      } = await spouts({
+        clientManifest,
+        req,
+        res,
+        nonce
+      });
+      let didError = false;
+      const {
+        pipe,
+        abort
+      } = reactRender(app, {
+        nonce,
+        //bootstrapScripts: assets.filter(asset => asset.endsWith('.js')),
+        onShellReady() {
+          //managers.forEach(manager => manager.cleanup());
+          // If something errored before we started streaming, we set the error code appropriately.
+          res.statusCode = didError ? 500 : 200;
+          res.setHeader('Content-type', 'text/html');
+          pipe(res);
+        },
+        onShellError() {
+          didError = true;
+          res.statusCode = 500;
+          pipe(res);
+        },
+        onError(e) {
+          didError = true;
+          console.error(e);
+          res.statusCode = 500;
+          //pipe(res); Removing this avoids, "React currently only supports piping to one writable stream."
+          if (onError) onError(e);
+        }
+      });
+      // Abandon and switch to client rendering if enough time passes.
+      // Try lowering this to see the client recover.
+      setTimeout(() => abort(`Timeout of ${timeoutMS}ms exceeded`), timeoutMS);
+    } catch (e) {
+      if (onError) onError(e);
+      throw e;
+    }
+  };
+  return render;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/scripts/scripts/getProxyMiddlewares.js

@@ -0,0 +1,93 @@
+// Essentially taken from https://github.com/webpack/webpack-dev-server/blob/b5e5b67398f97c7a2934e12ebe34fb03cc06c473/lib/Server.js#L2123
+export default function getProxyMiddlewares(proxyConfig) {
+  const middlewares = [];
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  const {
+    createProxyMiddleware
+  } = require('http-proxy-middleware');
+  const proxy = !Array.isArray(proxyConfig) && typeof proxyConfig === 'object' ? Object.keys(proxyConfig).length && Object.keys(proxyConfig)[0].startsWith('/') ? Object.entries(proxyConfig).map(([path, v]) => ({
+    path,
+    ...v
+  })) : [proxyConfig] : proxyConfig;
+  const getProxyMiddleware = proxyConfig => {
+    // It is possible to use the `bypass` method without a `target` or `router`.
+    // However, the proxy middleware has no use in this case, and will fail to instantiate.
+    if (proxyConfig.target) {
+      const context = proxyConfig.context || proxyConfig.path;
+      return createProxyMiddleware( /** @type {string} */context, proxyConfig);
+    }
+    if (proxyConfig.router) {
+      return createProxyMiddleware(proxyConfig);
+    }
+  };
+
+  /**
+   * Assume a proxy configuration specified as:
+   * proxy: [
+   *   {
+   *     context: "value",
+   *     ...options,
+   *   },
+   *   // or:
+   *   function() {
+   *     return {
+   *       context: "context",
+   *       ...options,
+   *     };
+   *   }
+   * ]
+   */
+  proxy.forEach(proxyConfigOrCallback => {
+    let proxyMiddleware;
+    let proxyConfig = typeof proxyConfigOrCallback === 'function' ? proxyConfigOrCallback() : proxyConfigOrCallback;
+    proxyMiddleware = getProxyMiddleware(proxyConfig);
+
+    /* TODO: figure out how to make this work
+    if (proxyConfig.ws) {
+      this.webSocketProxies.push(proxyMiddleware);
+    }
+    */
+
+    const handler = async (req, res, next) => {
+      if (typeof proxyConfigOrCallback === 'function') {
+        const newProxyConfig = proxyConfigOrCallback(req, res, next);
+        if (newProxyConfig !== proxyConfig) {
+          proxyConfig = newProxyConfig;
+          proxyMiddleware = getProxyMiddleware(proxyConfig);
+        }
+      }
+
+      // - Check if we have a bypass function defined
+      // - In case the bypass function is defined we'll retrieve the
+      // bypassUrl from it otherwise bypassUrl would be null
+      // TODO remove in the next major in favor `context` and `router` options
+      const bypassUrl = typeof proxyConfig.bypass === 'function' ? await proxyConfig.bypass(req, res, proxyConfig) : null;
+      if (typeof bypassUrl === 'boolean') {
+        // skip the proxy
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        req.url = null;
+        next();
+      } else if (typeof bypassUrl === 'string') {
+        // byPass to that url
+        req.url = bypassUrl;
+        next();
+      } else if (proxyMiddleware) {
+        return proxyMiddleware(req, res, next);
+      } else {
+        next();
+      }
+    };
+    middlewares.push({
+      name: 'http-proxy-middleware',
+      middleware: handler
+    });
+    // Also forward error requests to the proxy so it can handle them.
+    middlewares.push({
+      name: 'http-proxy-middleware-error-handler',
+      middleware: (error, req, res, next) => handler(req, res, next)
+    });
+  });
+  return middlewares;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["getProxyMiddlewares","proxyConfig","middlewares","createProxyMiddleware","require","proxy","Array","isArray","Object","keys","length","startsWith","entries","map","path","v","getProxyMiddleware","target","context","router","forEach","proxyConfigOrCallback","proxyMiddleware","handler","req","res","next","newProxyConfig","bypassUrl","bypass","url","push","name","middleware","error"],"sources":["../../../src/scripts/getProxyMiddlewares.ts"],"sourcesContent":["import {\n  RequestHandler,\n  ProxyConfigArray,\n  Response,\n  Request,\n  NextFunction,\n  ByPass,\n  ProxyConfigArrayItem,\n  ProxyConfigMap,\n} from 'webpack-dev-server';\n\n// Essentially taken from https://github.com/webpack/webpack-dev-server/blob/b5e5b67398f97c7a2934e12ebe34fb03cc06c473/lib/Server.js#L2123\nexport default function getProxyMiddlewares(\n  proxyConfig: ProxyConfigArrayItem | ProxyConfigMap | ProxyConfigArray,\n) {\n  const middlewares: any[] = [];\n  // eslint-disable-next-line @typescript-eslint/no-var-requires\n  const { createProxyMiddleware } = require('http-proxy-middleware');\n\n  const proxy: ProxyConfigArray =\n    !Array.isArray(proxyConfig) && typeof proxyConfig === 'object'\n      ? Object.keys(proxyConfig).length &&\n        Object.keys(proxyConfig)[0].startsWith('/')\n        ? Object.entries(proxyConfig).map(([path, v]) => ({ path, ...v }))\n        : [proxyConfig]\n      : proxyConfig;\n\n  const getProxyMiddleware = (\n    proxyConfig: ProxyConfigArrayItem,\n  ): RequestHandler | undefined => {\n    // It is possible to use the `bypass` method without a `target` or `router`.\n    // However, the proxy middleware has no use in this case, and will fail to instantiate.\n    if (proxyConfig.target) {\n      const context = proxyConfig.context || proxyConfig.path;\n\n      return createProxyMiddleware(/** @type {string} */ context, proxyConfig);\n    }\n\n    if (proxyConfig.router) {\n      return createProxyMiddleware(proxyConfig);\n    }\n  };\n\n  /**\n   * Assume a proxy configuration specified as:\n   * proxy: [\n   *   {\n   *     context: \"value\",\n   *     ...options,\n   *   },\n   *   // or:\n   *   function() {\n   *     return {\n   *       context: \"context\",\n   *       ...options,\n   *     };\n   *   }\n   * ]\n   */\n  proxy.forEach(proxyConfigOrCallback => {\n    let proxyMiddleware: RequestHandler | undefined;\n\n    let proxyConfig =\n      typeof proxyConfigOrCallback === 'function'\n        ? proxyConfigOrCallback()\n        : proxyConfigOrCallback;\n\n    proxyMiddleware = getProxyMiddleware(proxyConfig);\n\n    /* TODO: figure out how to make this work\n    if (proxyConfig.ws) {\n      this.webSocketProxies.push(proxyMiddleware);\n    }\n    */\n\n    const handler = async (req: Request, res: Response, next: NextFunction) => {\n      if (typeof proxyConfigOrCallback === 'function') {\n        const newProxyConfig = proxyConfigOrCallback(req, res, next);\n\n        if (newProxyConfig !== proxyConfig) {\n          proxyConfig = newProxyConfig;\n          proxyMiddleware = getProxyMiddleware(proxyConfig);\n        }\n      }\n\n      // - Check if we have a bypass function defined\n      // - In case the bypass function is defined we'll retrieve the\n      // bypassUrl from it otherwise bypassUrl would be null\n      // TODO remove in the next major in favor `context` and `router` options\n      const bypassUrl: ByPass | null =\n        typeof proxyConfig.bypass === 'function'\n          ? await proxyConfig.bypass(req, res, proxyConfig)\n          : null;\n\n      if (typeof bypassUrl === 'boolean') {\n        // skip the proxy\n        // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n        // @ts-ignore\n        req.url = null;\n        next();\n      } else if (typeof bypassUrl === 'string') {\n        // byPass to that url\n        req.url = bypassUrl;\n        next();\n      } else if (proxyMiddleware) {\n        return proxyMiddleware(req, res, next);\n      } else {\n        next();\n      }\n    };\n\n    middlewares.push({\n      name: 'http-proxy-middleware',\n      middleware: handler,\n    });\n    // Also forward error requests to the proxy so it can handle them.\n    middlewares.push({\n      name: 'http-proxy-middleware-error-handler',\n      middleware: (\n        error: Error,\n        req: Request,\n        res: Response,\n        next: NextFunction,\n      ) => handler(req, res, next),\n    });\n  });\n\n  return middlewares;\n}\n"],"mappings":"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"}

package/lib/scripts/scripts/getWebpackConfig.js

@@ -0,0 +1,16 @@
+import { default as enhanced } from 'enhanced-resolve';
+const resolve = enhanced.create.sync({
+  modules: ['.'],
+  // or resolve.create.sync
+  extensions: ['.js', '.cjs', '.mjs']
+  // see more options below
+});
+
+export async function getWebpackConfig() {
+  const configPath = resolve({}, process.cwd(), 'webpack.config');
+  if (!configPath) {
+    throw new Error('Cannot find webpack.config in ' + process.cwd());
+  }
+  return (await import(configPath)).default;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJkZWZhdWx0IiwiZW5oYW5jZWQiLCJyZXNvbHZlIiwiY3JlYXRlIiwic3luYyIsIm1vZHVsZXMiLCJleHRlbnNpb25zIiwiZ2V0V2VicGFja0NvbmZpZyIsImNvbmZpZ1BhdGgiLCJwcm9jZXNzIiwiY3dkIiwiRXJyb3IiXSwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc2NyaXB0cy9nZXRXZWJwYWNrQ29uZmlnLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGRlZmF1bHQgYXMgZW5oYW5jZWQgfSBmcm9tICdlbmhhbmNlZC1yZXNvbHZlJztcbmltcG9ydCB3ZWJwYWNrIGZyb20gJ3dlYnBhY2snO1xuXG5jb25zdCByZXNvbHZlID0gZW5oYW5jZWQuY3JlYXRlLnN5bmMoe1xuICBtb2R1bGVzOiBbJy4nXSxcbiAgLy8gb3IgcmVzb2x2ZS5jcmVhdGUuc3luY1xuICBleHRlbnNpb25zOiBbJy5qcycsICcuY2pzJywgJy5tanMnXSxcbiAgLy8gc2VlIG1vcmUgb3B0aW9ucyBiZWxvd1xufSk7XG5cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBnZXRXZWJwYWNrQ29uZmlnKCk6IFByb21pc2U8XG4gIChlbnY6IGFueSwgYXJndjogYW55KSA9PiB3ZWJwYWNrLkNvbmZpZ3VyYXRpb25cbj4ge1xuICBjb25zdCBjb25maWdQYXRoID0gcmVzb2x2ZSh7fSwgcHJvY2Vzcy5jd2QoKSwgJ3dlYnBhY2suY29uZmlnJyk7XG4gIGlmICghY29uZmlnUGF0aCkge1xuICAgIHRocm93IG5ldyBFcnJvcignQ2Fubm90IGZpbmQgd2VicGFjay5jb25maWcgaW4gJyArIHByb2Nlc3MuY3dkKCkpO1xuICB9XG5cbiAgcmV0dXJuIChhd2FpdCBpbXBvcnQoY29uZmlnUGF0aCkpLmRlZmF1bHQ7XG59XG4iXSwibWFwcGluZ3MiOiJBQUFBLFNBQVNBLE9BQU8sSUFBSUMsUUFBUSxRQUFRLGtCQUFrQjtBQUd0RCxNQUFNQyxPQUFPLEdBQUdELFFBQVEsQ0FBQ0UsTUFBTSxDQUFDQyxJQUFJLENBQUM7RUFDbkNDLE9BQU8sRUFBRSxDQUFDLEdBQUcsQ0FBQztFQUNkO0VBQ0FDLFVBQVUsRUFBRSxDQUFDLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTTtFQUNsQztBQUNGLENBQUMsQ0FBQzs7QUFFRixPQUFPLGVBQWVDLGdCQUFnQkEsQ0FBQSxFQUVwQztFQUNBLE1BQU1DLFVBQVUsR0FBR04sT0FBTyxDQUFDLENBQUMsQ0FBQyxFQUFFTyxPQUFPLENBQUNDLEdBQUcsRUFBRSxFQUFFLGdCQUFnQixDQUFDO0VBQy9ELElBQUksQ0FBQ0YsVUFBVSxFQUFFO0lBQ2YsTUFBTSxJQUFJRyxLQUFLLENBQUMsZ0NBQWdDLEdBQUdGLE9BQU8sQ0FBQ0MsR0FBRyxFQUFFLENBQUM7RUFDbkU7RUFFQSxPQUFPLENBQUMsTUFBTSxNQUFNLENBQUNGLFVBQVUsQ0FBQyxFQUFFUixPQUFPO0FBQzNDIn0=

package/lib/scripts/scripts/index.js

@@ -0,0 +1,3 @@
+export { default as serve } from './serve.js';
+export { default as devServe } from './startDevserver.js';
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJkZWZhdWx0Iiwic2VydmUiLCJkZXZTZXJ2ZSJdLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zY3JpcHRzL2luZGV4LnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IGRlZmF1bHQgYXMgc2VydmUgfSBmcm9tICcuL3NlcnZlLmpzJztcbmV4cG9ydCB7IGRlZmF1bHQgYXMgZGV2U2VydmUgfSBmcm9tICcuL3N0YXJ0RGV2c2VydmVyLmpzJztcbiJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBU0EsT0FBTyxJQUFJQyxLQUFLLFFBQVEsWUFBWTtBQUM3QyxTQUFTRCxPQUFPLElBQUlFLFFBQVEsUUFBUSxxQkFBcUIifQ==

package/lib/scripts/scripts/serve.js

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+Object.hasOwn = Object.hasOwn || /* istanbul ignore next */function hasOwn(it, key) {
+  return Object.prototype.hasOwnProperty.call(it, key);
+};
+import compress from 'compression';
+import express from 'express';
+import diskFs from 'fs';
+import ora from 'ora';
+import path from 'path';
+import { promisify } from 'util';
+import 'cross-fetch/dist/node-polyfill.js';
+import getProxyMiddlewares from './getProxyMiddlewares.js';
+import { getWebpackConfig } from './getWebpackConfig.js';
+// run directly from node
+if ('main' in import.meta) {
+  const entrypoint = process.argv[2];
+  if (!entrypoint) {
+    console.log(`Usage: ${process.argv[0]} <server-entrypoint>`);
+    process.exit(-1);
+  }
+  serve(entrypoint);
+}
+export default async function serve(entrypoint, options = {}) {
+  const PORT = process.env.PORT || 8080;
+  const loader = ora('Initializing').start();
+  const webpackConfig = await getWebpackConfig();
+  const manifestPath = getManifestPathFromWebpackconfig(webpackConfig({}, {
+    mode: 'production'
+  }));
+  const readFile = promisify(diskFs.readFile);
+  let server;
+  function handleErrors(fn) {
+    return async function (req, res, next) {
+      try {
+        return await fn(req, res);
+      } catch (x) {
+        next(x);
+      }
+    };
+  }
+
+  // Start the express server after the first compilation
+  async function initializeApp(clientManifest) {
+    loader.info('Launching server');
+    if (!clientManifest) {
+      loader.fail('Manifest not found');
+      // TODO: handle more gracefully
+      process.exit(-1);
+    }
+    const wrappingApp = express();
+    // eslint-disable-next-line
+    //@ts-ignore
+    wrappingApp.use(compress());
+
+    // ASSETS
+    if (options.serveAssets) {
+      wrappingApp.use(async (req, res, next) => {
+        var _req$url$substring, _req$url, _clientManifest$outpu;
+        const filename = (_req$url$substring = (_req$url = req.url) == null ? void 0 : _req$url.substring(process.env.WEBPACK_PUBLIC_PATH.length)) != null ? _req$url$substring : '';
+        const assetPath = path.join((_clientManifest$outpu = clientManifest.outputPath) != null ? _clientManifest$outpu : '', filename);
+        if (diskFs.existsSync(assetPath) && !diskFs.lstatSync(assetPath).isDirectory()) {
+          try {
+            res.sendFile(assetPath);
+          } catch (e) {
+            return next();
+          }
+        } else {
+          next();
+        }
+      });
+    }
+
+    // PROXIES
+    if (options.serveProxy) {
+      var _devConfig$devServer;
+      const devConfig = webpackConfig({}, {
+        mode: 'development'
+      });
+      if ((_devConfig$devServer = devConfig.devServer) != null && _devConfig$devServer.proxy) {
+        var _devConfig$devServer2;
+        const middlewares = getProxyMiddlewares((_devConfig$devServer2 = devConfig.devServer) == null ? void 0 : _devConfig$devServer2.proxy);
+        if (middlewares) {
+          wrappingApp.use(...middlewares.map(({
+            middleware
+          }) => middleware));
+        }
+      }
+    }
+
+    // SERVER SIDE RENDERING
+    let render = (await import(path.join(process.cwd(), entrypoint))).default;
+    if ('default' in render) {
+      render = render.default;
+    }
+    if (typeof render !== 'function') {
+      throw new Error(`default export of ${path.join(process.cwd(), entrypoint)} is not a function`);
+    }
+    wrappingApp.get('/*', handleErrors(async function (req, res) {
+      if (req.url.endsWith('favicon.ico')) {
+        res.statusCode = 404;
+        res.setHeader('Content-type', 'text/html');
+        res.send('not found');
+        return;
+      }
+      res.socket.on('error', error => {
+        console.error('Fatal', error);
+      });
+      await render(clientManifest, req, res);
+    }));
+    server = wrappingApp.listen(PORT, () => {
+      loader.info(`Listening at ${PORT}...`);
+    }).on('error', function (error) {
+      if (error.syscall !== 'listen') {
+        throw error;
+      }
+      const isPipe = portOrPipe => Number.isNaN(portOrPipe);
+      const bind = isPipe(PORT) ? 'Pipe ' + PORT : 'Port ' + PORT;
+      switch (error.code) {
+        case 'EACCES':
+          loader.fail(bind + ' requires elevated privileges');
+          process.exit(1);
+        // eslint-disable-next-line no-fallthrough
+        case 'EADDRINUSE':
+          loader.fail(bind + ' is already in use');
+          process.exit(1);
+        // eslint-disable-next-line no-fallthrough
+        default:
+          throw error;
+      }
+    });
+  }
+  let manifest = await import(manifestPath, {
+    assert: {
+      type: 'json'
+    }
+  });
+  // handle inconsistent import conditions
+  if ('default' in manifest) {
+    manifest = manifest.default;
+  }
+  await initializeApp(manifest);
+  process.on('SIGINT', () => {
+    var _server;
+    loader.warn('Received SIGINT, devserver shutting down');
+    if (server) console.log('Closing server');
+    (_server = server) == null ? void 0 : _server.close(() => {
+      loader.info('Server closed');
+    });
+    process.exit(-1);
+  });
+}
+function getManifestPathFromWebpackconfig(webpackConfig) {
+  var _opts$filename, _webpackConfig$plugin, _webpackConfig$plugin2, _webpackConfig$plugin3, _webpackConfig$output, _webpackConfig$output2;
+  const manifestFilename = (_opts$filename = webpackConfig == null ? void 0 : (_webpackConfig$plugin = webpackConfig.plugins) == null ? void 0 : (_webpackConfig$plugin2 = _webpackConfig$plugin.find(plugin => {
+    return plugin.constructor.name === 'StatsWriterPlugin';
+  })) == null ? void 0 : (_webpackConfig$plugin3 = _webpackConfig$plugin2.opts) == null ? void 0 : _webpackConfig$plugin3.filename) != null ? _opts$filename : 'manifest.json';
+  const manifestPath = path.join((_webpackConfig$output = webpackConfig == null ? void 0 : (_webpackConfig$output2 = webpackConfig.output) == null ? void 0 : _webpackConfig$output2.path) != null ? _webpackConfig$output : '', manifestFilename);
+  return manifestPath;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["Object","hasOwn","it","key","prototype","hasOwnProperty","call","compress","express","diskFs","ora","path","promisify","getProxyMiddlewares","getWebpackConfig","import","meta","entrypoint","process","argv","console","log","exit","serve","options","PORT","env","loader","start","webpackConfig","manifestPath","getManifestPathFromWebpackconfig","mode","readFile","server","handleErrors","fn","req","res","next","x","initializeApp","clientManifest","info","fail","wrappingApp","use","serveAssets","_req$url$substring","_req$url","_clientManifest$outpu","filename","url","substring","WEBPACK_PUBLIC_PATH","length","assetPath","join","outputPath","existsSync","lstatSync","isDirectory","sendFile","e","serveProxy","_devConfig$devServer","devConfig","devServer","proxy","_devConfig$devServer2","middlewares","map","middleware","render","cwd","default","Error","get","endsWith","statusCode","setHeader","send","socket","on","error","listen","syscall","isPipe","portOrPipe","Number","isNaN","bind","code","manifest","assert","type","_server","warn","close","_opts$filename","_webpackConfig$plugin","_webpackConfig$plugin2","_webpackConfig$plugin3","_webpackConfig$output","_webpackConfig$output2","manifestFilename","plugins","find","plugin","constructor","name","opts","output"],"sources":["../../../src/scripts/serve.ts"],"sourcesContent":["#!/usr/bin/env node\nObject.hasOwn =\n  Object.hasOwn ||\n  /* istanbul ignore next */ function hasOwn(it, key) {\n    return Object.prototype.hasOwnProperty.call(it, key);\n  };\nimport compress from 'compression';\nimport express, { NextFunction } from 'express';\nimport diskFs from 'fs';\nimport { Server, IncomingMessage, ServerResponse } from 'http';\nimport ora from 'ora';\nimport path from 'path';\nimport { promisify } from 'util';\nimport webpack from 'webpack';\n\nimport 'cross-fetch/dist/node-polyfill.js';\nimport getProxyMiddlewares from './getProxyMiddlewares.js';\nimport { getWebpackConfig } from './getWebpackConfig.js';\nimport { Render } from './types.js';\n\n// run directly from node\nif ('main' in import.meta) {\n  const entrypoint = process.argv[2];\n\n  if (!entrypoint) {\n    console.log(`Usage: ${process.argv[0]} <server-entrypoint>`);\n    process.exit(-1);\n  }\n  serve(entrypoint);\n}\n\nexport default async function serve(\n  entrypoint: string,\n  options: { serveAssets?: boolean; serveProxy?: boolean } = {},\n) {\n  const PORT = process.env.PORT || 8080;\n\n  const loader = ora('Initializing').start();\n\n  const webpackConfig = await getWebpackConfig();\n\n  const manifestPath = getManifestPathFromWebpackconfig(\n    webpackConfig({}, { mode: 'production' }),\n  );\n\n  const readFile = promisify(diskFs.readFile);\n  let server: Server | undefined;\n\n  function handleErrors<\n    F extends (\n      req: Request | IncomingMessage,\n      res: Response | ServerResponse,\n    ) => Promise<void>,\n  >(fn: F) {\n    return async function (\n      req: Request | IncomingMessage,\n      res: Response | ServerResponse,\n      next: NextFunction,\n    ) {\n      try {\n        return await fn(req, res);\n      } catch (x) {\n        next(x);\n      }\n    };\n  }\n\n  // Start the express server after the first compilation\n  async function initializeApp(clientManifest: webpack.StatsCompilation) {\n    loader.info('Launching server');\n    if (!clientManifest) {\n      loader.fail('Manifest not found');\n      // TODO: handle more gracefully\n      process.exit(-1);\n    }\n\n    const wrappingApp = express();\n    // eslint-disable-next-line\n    //@ts-ignore\n    wrappingApp.use(compress());\n\n    // ASSETS\n    if (options.serveAssets) {\n      wrappingApp.use(\n        async (\n          req: Request | IncomingMessage,\n          res: any,\n          next: NextFunction,\n        ) => {\n          const filename =\n            req.url?.substring(\n              (process.env.WEBPACK_PUBLIC_PATH as string).length,\n            ) ?? '';\n          const assetPath = path.join(\n            clientManifest.outputPath ?? '',\n            filename,\n          );\n\n          if (\n            diskFs.existsSync(assetPath) &&\n            !diskFs.lstatSync(assetPath).isDirectory()\n          ) {\n            try {\n              res.sendFile(assetPath);\n            } catch (e) {\n              return next();\n            }\n          } else {\n            next();\n          }\n        },\n      );\n    }\n\n    // PROXIES\n    if (options.serveProxy) {\n      const devConfig: webpack.Configuration = webpackConfig(\n        {},\n        { mode: 'development' },\n      );\n      if (devConfig.devServer?.proxy) {\n        const middlewares = getProxyMiddlewares(devConfig.devServer?.proxy);\n        if (middlewares) {\n          wrappingApp.use(...middlewares.map(({ middleware }) => middleware));\n        }\n      }\n    }\n\n    // SERVER SIDE RENDERING\n    let render: Render = (await import(path.join(process.cwd(), entrypoint)))\n      .default;\n\n    if ('default' in render) {\n      render = render.default as any;\n    }\n\n    if (typeof render !== 'function') {\n      throw new Error(\n        `default export of ${path.join(\n          process.cwd(),\n          entrypoint,\n        )} is not a function`,\n      );\n    }\n\n    wrappingApp.get(\n      '/*',\n      handleErrors(async function (req: any, res: any) {\n        if (req.url.endsWith('favicon.ico')) {\n          res.statusCode = 404;\n          res.setHeader('Content-type', 'text/html');\n          res.send('not found');\n          return;\n        }\n        res.socket.on('error', (error: unknown) => {\n          console.error('Fatal', error);\n        });\n\n        await render(clientManifest, req, res);\n      }),\n    );\n\n    server = wrappingApp\n      .listen(PORT, () => {\n        loader.info(`Listening at ${PORT}...`);\n      })\n      .on('error', function (error: any) {\n        if (error.syscall !== 'listen') {\n          throw error;\n        }\n        const isPipe = (portOrPipe: string | number) =>\n          Number.isNaN(portOrPipe);\n        const bind = isPipe(PORT) ? 'Pipe ' + PORT : 'Port ' + PORT;\n        switch (error.code) {\n          case 'EACCES':\n            loader.fail(bind + ' requires elevated privileges');\n            process.exit(1);\n          // eslint-disable-next-line no-fallthrough\n          case 'EADDRINUSE':\n            loader.fail(bind + ' is already in use');\n            process.exit(1);\n          // eslint-disable-next-line no-fallthrough\n          default:\n            throw error;\n        }\n      });\n  }\n\n  let manifest = await import(manifestPath, {\n    assert: { type: 'json' },\n  });\n  // handle inconsistent import conditions\n  if ('default' in manifest) {\n    manifest = manifest.default;\n  }\n  await initializeApp(manifest);\n\n  process.on('SIGINT', () => {\n    loader.warn('Received SIGINT, devserver shutting down');\n    if (server) console.log('Closing server');\n    server?.close(() => {\n      loader.info('Server closed');\n    });\n    process.exit(-1);\n  });\n}\n\nfunction getManifestPathFromWebpackconfig(\n  webpackConfig: webpack.Configuration,\n) {\n  const manifestFilename: string =\n    (\n      webpackConfig?.plugins?.find(plugin => {\n        return plugin.constructor.name === 'StatsWriterPlugin';\n      }) as any\n    )?.opts?.filename ?? 'manifest.json';\n\n  const manifestPath = path.join(\n    webpackConfig?.output?.path ?? '',\n    manifestFilename,\n  );\n  return manifestPath;\n}\n"],"mappings":"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"}