@dr.pogodin/react-utils 1.46.2 → 1.47.0-alpha.11

package/{src/server/renderer.tsx → build/web/server/renderer.js}

@@ -1,104 +1,67 @@
+import "core-js/modules/es.iterator.constructor.js";
+import "core-js/modules/es.iterator.for-each.js";
+import "core-js/modules/es.iterator.map.js";
+import "core-js/modules/es.set.difference.v2.js";
+import "core-js/modules/es.set.intersection.v2.js";
+import "core-js/modules/es.set.is-disjoint-from.v2.js";
+import "core-js/modules/es.set.is-subset-of.v2.js";
+import "core-js/modules/es.set.is-superset-of.v2.js";
+import "core-js/modules/es.set.symmetric-difference.v2.js";
+import "core-js/modules/es.set.union.v2.js";
 /**
  * ExpressJS middleware for server-side rendering of a ReactJS app.
  */
 
+import { Buffer } from 'node:buffer';
+import { createCipheriv, randomBytes } from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import { Writable } from 'node:stream';
 import { brotliCompress, brotliDecompress } from 'node:zlib';
-
-import type { Request, RequestHandler } from 'express';
-import type { ComponentType } from 'react';
-import type { Configuration, Stats } from 'webpack';
 import winston from 'winston';
-
 import { GlobalStateProvider, SsrContext } from '@dr.pogodin/react-global-state';
 import { timer } from '@dr.pogodin/js-utils';
-
-import {
-  clone,
-  cloneDeep,
-  defaults,
-  get,
-  isString,
-  mapValues,
-  omit,
-} from 'lodash';
-
+import { cloneDeep, defaults, get, mapValues } from 'lodash-es';
 import config from 'config';
-import forge from 'node-forge';
-
 import { prerenderToNodeStream } from 'react-dom/static';
-import { type HelmetDataContext, HelmetProvider } from '@dr.pogodin/react-helmet';
+import { HelmetProvider } from '@dr.pogodin/react-helmet';
 import { StaticRouter } from 'react-router';
 import serializeJs from 'serialize-javascript';
-import { type BuildInfoT, setBuildInfo } from 'utils/isomorphy/buildInfo';
-
-import type { ChunkGroupsT, SsrContextT } from 'utils/globalState';
+import { setBuildInfo } from "../shared/utils/isomorphy/buildInfo";
+import Cache from "./Cache";
 
-import Cache from './Cache';
-
-const sanitizedConfig = omit(config, 'SECRET');
+// @ts-expect-error "Property 'SECRET' does not exist on type 'IConfig'."
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+import { jsx as _jsx } from "react/jsx-runtime";
+const {
+  SECRET,
+  ...sanitizedConfig
+} = config;
 
 // Note: These type definitions for logger are copied from Winston logger,
 // then simplified to make it easier to fit an alternative logger into this
 // interface.
 // eslint-disable-next-line @typescript-eslint/consistent-type-definitions
-interface LogMethodI {
-  // eslint-disable-next-line @typescript-eslint/prefer-function-type
-  (level: string, message: string, ...meta: unknown[]): void;
-}
 
 // eslint-disable-next-line @typescript-eslint/consistent-type-definitions
-interface LeveledLogMethodI {
-  // eslint-disable-next-line @typescript-eslint/prefer-function-type
-  (message: string, ...meta: unknown[]): void;
-}
 
 // eslint-disable-next-line @typescript-eslint/consistent-type-definitions
-export interface LoggerI {
-  debug: LeveledLogMethodI;
-  error: LeveledLogMethodI;
-  info: LeveledLogMethodI;
-  log: LogMethodI;
-  warn: LeveledLogMethodI;
-}
-
-export enum SCRIPT_LOCATIONS {
-  BODY_OPEN = 'BODY_OPEN',
-  DEFAULT = 'DEFAULT',
-  HEAD_OPEN = 'HEAD_OPEN',
-}
-
-export class ServerSsrContext<StateT>
-  extends SsrContext<StateT>
-  implements SsrContextT<StateT> {
-  chunkGroups: ChunkGroupsT;
-
-  chunks: string[] = [];
-
-  redirectTo?: string;
-
-  req: Request;
 
-  status: number = 200;
-
-  constructor(
-    req: Request,
-    chunkGroups: ChunkGroupsT,
-    initialState?: StateT,
-  ) {
-    super(cloneDeep(initialState) ?? ({} as StateT));
+export let SCRIPT_LOCATIONS = /*#__PURE__*/function (SCRIPT_LOCATIONS) {
+  SCRIPT_LOCATIONS["BODY_OPEN"] = "BODY_OPEN";
+  SCRIPT_LOCATIONS["DEFAULT"] = "DEFAULT";
+  SCRIPT_LOCATIONS["HEAD_OPEN"] = "HEAD_OPEN";
+  return SCRIPT_LOCATIONS;
+}({});
+export class ServerSsrContext extends SsrContext {
+  chunks = [];
+  status = 200;
+  constructor(req, chunkGroups, initialState) {
+    super(cloneDeep(initialState) ?? {});
     this.chunkGroups = chunkGroups;
     this.req = req;
   }
 }
-
-type ScriptT = {
-  code: string;
-  location: SCRIPT_LOCATIONS;
-};
-
 /**
  * Reads build-time information about the app. This information is generated
  * by our standard Webpack config for apps, and it is written into
@@ -108,9 +71,9 @@ type ScriptT = {
  * @param context Webpack context path used during the build.
  * @return Resolves to the build-time information.
  */
-function getBuildInfo(context: string) {
+function getBuildInfo(context) {
   const url = path.resolve(context, '.build-info');
-  return JSON.parse(fs.readFileSync(url, 'utf8')) as BuildInfoT;
+  return JSON.parse(fs.readFileSync(url, 'utf8'));
 }
 
 /**
@@ -121,11 +84,11 @@ function getBuildInfo(context: string) {
  * @param buildDir
  * @return
  */
-function readChunkGroupsJson(buildDir: string) {
+function readChunkGroupsJson(buildDir) {
   const url = path.resolve(buildDir, '__chunk_groups__.json');
   let res;
   try {
-    res = JSON.parse(fs.readFileSync(url, 'utf8')) as Record<string, string[]>;
+    res = JSON.parse(fs.readFileSync(url, 'utf8'));
   } catch {
     // TODO: Should we message the error here somehow?
     res = null;
@@ -135,26 +98,15 @@ function readChunkGroupsJson(buildDir: string) {
 
 /**
  * Prepares a new Cipher for data encryption.
- * @param key Encryption key (32-bit random key is expected, see
- *  node-forge documentation, in case of doubts).
- * @return Resolves to the object with two fields:
+ * @param key Encryption key (32-bit random, Base64-encoded key is expected).
+ * @return Returns a tuple of:
  *  1. cipher - a new Cipher, ready for encryption;
  *  2. iv - initial vector used by the cipher.
  */
-async function prepareCipher(key: string): Promise<{
-  cipher: forge.cipher.BlockCipher;
-  iv: string;
-}> {
-  return new Promise((resolve, reject) => {
-    forge.random.getBytes(32, (err, iv) => {
-      if (err) reject(err);
-      else {
-        const cipher = forge.cipher.createCipher('AES-CBC', key);
-        cipher.start({ iv });
-        resolve({ cipher, iv });
-      }
-    });
-  });
+function prepareCipher(key) {
+  const iv = randomBytes(16);
+  const cipher = createCipheriv('AES-256-CBC', Buffer.from(key, 'base64'), iv);
+  return [cipher, iv];
 }
 
 /**
@@ -162,14 +114,13 @@ async function prepareCipher(key: string): Promise<{
  * are acceptable to the caller.
  * @param req
  */
-export function isBrotliAcceptable(req: Request): boolean {
+export function isBrotliAcceptable(req) {
   const acceptable = req.get('accept-encoding');
   if (acceptable) {
     const ops = acceptable.split(',');
     for (const op of ops) {
       const [type, priority] = op.trim().split(';q=');
-      if ((type === '*' || type === 'br')
-        && (!priority || parseFloat(priority) > 0)) {
+      if ((type === '*' || type === 'br') && (!priority || parseFloat(priority) > 0)) {
         return true;
       }
     }
@@ -191,18 +142,17 @@ export function isBrotliAcceptable(req: Request): boolean {
  *  HEAD_OPEN: string[];
  * }}
  */
-function groupExtraScripts(scripts: Array<string | ScriptT> = []) {
+function groupExtraScripts(scripts = []) {
   const res = {
     [SCRIPT_LOCATIONS.BODY_OPEN]: '',
     [SCRIPT_LOCATIONS.DEFAULT]: '',
-    [SCRIPT_LOCATIONS.HEAD_OPEN]: '',
+    [SCRIPT_LOCATIONS.HEAD_OPEN]: ''
   };
   for (const script of scripts) {
-    if (isString(script)) {
+    if (typeof script === 'string') {
       if (script) res[SCRIPT_LOCATIONS.DEFAULT] += script;
     } else if (script.code) {
-      if (script.location in res) res[script.location] += script.code;
-      else throw Error(`Invalid location "${script.location}"`);
+      if (script.location in res) res[script.location] += script.code;else throw Error(`Invalid location "${script.location}"`);
     }
   }
   return res;
@@ -215,70 +165,31 @@ function groupExtraScripts(scripts: Array<string | ScriptT> = []) {
  * @return {object}
  */
 export function newDefaultLogger({
-  defaultLogLevel = 'info',
-} = {}): winston.Logger {
-  const { format, transports } = winston;
+  defaultLogLevel = 'info'
+} = {}) {
+  const {
+    format,
+    transports
+  } = winston;
   return winston.createLogger({
-    format: format.combine(
-      format.splat(),
-      format.timestamp(),
-      format.colorize(),
-      format.printf(
-        ({
-          level,
-          message,
-          timestamp,
-          stack,
-          ...rest
-        }) => {
-          let res = `${level}\t(at ${timestamp as string}):\t${message as string}`;
-          if (Object.keys(rest).length) {
-            res += `\n${JSON.stringify(rest, null, 2)}`;
-          }
-          if (stack) res += `\n${stack as string}`;
-          return res;
-        },
-      ),
-    ),
+    format: format.combine(format.splat(), format.timestamp(), format.colorize(), format.printf(({
+      level,
+      message,
+      timestamp,
+      stack,
+      ...rest
+    }) => {
+      let res = `${level}\t(at ${timestamp}):\t${message}`;
+      if (Object.keys(rest).length) {
+        res += `\n${JSON.stringify(rest, null, 2)}`;
+      }
+      if (stack) res += `\n${stack}`;
+      return res;
+    })),
     level: defaultLogLevel,
-    transports: [new transports.Console()],
+    transports: [new transports.Console()]
   });
 }
-
-export type ConfigT = {
-  [key: string]: ConfigT | string;
-};
-
-export type BeforeRenderResT = {
-  configToInject?: ConfigT;
-  extraScripts?: Array<ScriptT | string>;
-  initialState?: unknown;
-};
-
-export type BeforeRenderT = (
-  req: Request,
-  config: ConfigT,
-) => BeforeRenderResT | Promise<BeforeRenderResT>;
-
-type CacheRefT = {
-  key: string;
-  maxage?: number;
-};
-
-export type OptionsT = {
-  Application?: ComponentType;
-  beforeRender?: BeforeRenderT;
-  buildInfo?: BuildInfoT;
-  defaultLoggerLogLevel?: string;
-  favicon?: string;
-  logger?: LoggerI;
-  maxSsrRounds?: number;
-  noCsp?: boolean;
-  staticCacheSize?: number;
-  ssrTimeout?: number;
-  staticCacheController?: (req: Request) => CacheRefT | null | undefined;
-};
-
 /**
  * Creates the middleware.
  * @param webpackConfig
@@ -310,46 +221,36 @@ export type OptionsT = {
  *   If undefined - infinite age is assumed.
  * @return Created middleware.
  */
-export default function factory(
-  webpackConfig: Configuration,
-  options: OptionsT,
-): RequestHandler {
-  const ops: OptionsT = defaults(clone(options), {
+export default function factory(webpackConfig, options) {
+  const ops = defaults({
+    ...options
+  }, {
     beforeRender: async () => Promise.resolve({}),
     maxSsrRounds: 10,
     ssrTimeout: 1000,
-    staticCacheSize: 1.e7,
+    staticCacheSize: 1.e7
   });
 
   // Note: in normal use the default logger is created and set in the root
   // server function, and this initialization is for testing uses, where
   // renderer is imported directly.
   ops.logger ??= newDefaultLogger({
-    defaultLogLevel: ops.defaultLoggerLogLevel,
+    defaultLogLevel: ops.defaultLoggerLogLevel
   });
-
-  const buildInfo = ops.buildInfo ?? getBuildInfo(webpackConfig.context!);
+  const buildInfo = ops.buildInfo ?? getBuildInfo(webpackConfig.context);
   setBuildInfo(buildInfo);
 
   // publicPath from webpack.output has a trailing slash at the end.
-  const { publicPath, path: outputPath } = webpackConfig.output!;
-
-  const manifestLink = fs.existsSync(`${outputPath}/manifest.json`)
-    ? `<link rel="manifest" href="${publicPath as string}manifest.json">` : '';
+  const {
+    publicPath,
+    path: outputPath
+  } = webpackConfig.output;
+  const manifestLink = fs.existsSync(`${outputPath}/manifest.json`) ? `<link rel="manifest" href="${publicPath}manifest.json">` : '';
 
   // eslint-disable-next-line @typescript-eslint/consistent-type-definitions
-  interface BufferWithNonce extends ArrayBuffer {
-    nonce: string;
-  }
 
-  const cache = ops.staticCacheController
-    ? new Cache<{
-      buffer: BufferWithNonce;
-      status: number;
-    }>(ops.staticCacheSize!)
-    : null;
-
-  const CHUNK_GROUPS = readChunkGroupsJson(outputPath!);
+  const cache = ops.staticCacheController ? new Cache(ops.staticCacheSize) : null;
+  const CHUNK_GROUPS = readChunkGroupsJson(outputPath);
 
   // TODO: Look at it later.
   // eslint-disable-next-line complexity
@@ -357,26 +258,26 @@ export default function factory(
     try {
       // Ensures any caches always revalidate HTML markup before reuse.
       res.set('Cache-Control', 'no-cache');
-
       res.cookie('csrfToken', req.csrfToken());
-
-      let cacheRef: CacheRefT | null | undefined;
+      let cacheRef;
       if (cache) {
-        cacheRef = ops.staticCacheController!(req);
+        cacheRef = ops.staticCacheController(req);
         if (cacheRef) {
           const data = cache.get(cacheRef);
           if (data !== null) {
-            const { buffer, status } = data;
+            const {
+              buffer,
+              status
+            } = data;
             if (ops.noCsp && isBrotliAcceptable(req)) {
               res.set('Content-Type', 'text/html');
               res.set('Content-Encoding', 'br');
               if (status !== 200) res.status(status);
               res.send(buffer);
             } else {
-              await new Promise<void>((done, failed) => {
+              await new Promise((done, failed) => {
                 brotliDecompress(buffer, (error, html) => {
-                  if (error) failed(error);
-                  else {
+                  if (error) failed(error);else {
                     let h = html.toString();
                     if (!ops.noCsp) {
                       // TODO: Starting from Node v15 we'll be able to use string's
@@ -385,9 +286,7 @@ export default function factory(
                       const regex = new RegExp(buffer.nonce, 'g');
 
                       // TODO: It should be implemented more careful.
-                      h = h.replace(regex, (req as unknown as {
-                        nonce: string;
-                      }).nonce);
+                      h = h.replace(regex, req.nonce);
                     }
                     if (status !== 200) res.status(status);
                     res.send(h);
@@ -400,144 +299,115 @@ export default function factory(
           }
         }
       }
-
-      const brr = ops.beforeRender!(req, sanitizedConfig as unknown as ConfigT);
-
-      const [{
+      const brr = ops.beforeRender(req, sanitizedConfig);
+      const {
         configToInject,
         extraScripts,
-        initialState,
-      }, {
-        cipher,
-        iv,
-      }] = await Promise.all([
-        // NOTE: Written this way to avoid triggering the "await-thenable"
-        // ESLint rule.
-        brr instanceof Promise ? brr : Promise.resolve(brr),
-
-        prepareCipher(buildInfo.key),
-      ]);
-
-      let helmet: HelmetDataContext['helmet'];
+        initialState
+      } = await brr;
+      const [cipher, iv] = prepareCipher(buildInfo.key);
+      let helmet;
 
       // Gets the mapping between code chunk names and their asset files.
       // These data come from the Webpack compilation, either from the stats
       // attached to the request (in dev mode), or from a file output during
       // the build (in prod mode).
-      let chunkGroups: ChunkGroupsT;
-      const webpackStats = get(res.locals, 'webpack.devMiddleware.stats') as Stats | undefined;
+      let chunkGroups;
+      const webpackStats = get(res.locals, 'webpack.devMiddleware.stats');
       if (webpackStats) {
-        chunkGroups = mapValues(
-          webpackStats.toJson({
-            all: false,
-            chunkGroups: true,
-          }).namedChunkGroups,
-          (item) => item.assets?.map(({ name }: { name: string }) => name)
-            ?? [],
-        );
-      } else if (CHUNK_GROUPS) chunkGroups = CHUNK_GROUPS;
-      else chunkGroups = {};
+        chunkGroups = mapValues(webpackStats.toJson({
+          all: false,
+          chunkGroups: true
+        }).namedChunkGroups, item => item.assets?.map(({
+          name
+        }) => name) ?? []);
+      } else if (CHUNK_GROUPS) chunkGroups = CHUNK_GROUPS;else chunkGroups = {};
 
       /* Optional server-side rendering. */
       const App = ops.Application;
-      let appHtmlMarkup: string = '';
+      let appHtmlMarkup = '';
       const ssrContext = new ServerSsrContext(req, chunkGroups, initialState);
-      let stream: NodeJS.ReadableStream;
+      let stream;
       if (App) {
         const ssrStart = Date.now();
 
         // TODO: Somehow, without it TS does not realise that
         // App has been checked to exist.
         const App2 = App;
-
-        const renderPass = async () => new Promise<NodeJS.ReadableStream>(
-          (resolveArg, rejectArg) => {
-            ssrContext.chunks = [];
-
-            // NOTE: JS does not have problems if resolve() and reject() methods
-            // of a Promise are called multiple times, with different arguments;
-            // it only respects the first call, and ignores subsequent ones.
-            // We, however, really want to assert that here, to safeguard against
-            // any future problems due to unexpected internal changes in React,
-            // if any.
-            let error: unknown;
-
-            const resolve = (arg: NodeJS.ReadableStream) => {
-              if (error !== undefined) throw Error('Internal error');
-              error = null;
-              resolveArg(arg);
-            };
-
-            const reject = (arg: unknown) => {
-              if (error !== undefined && error !== arg) {
-                throw Error('Internal error');
-              }
-              error = arg;
-              rejectArg(arg as Error);
-            };
-
-            // TODO: prerenderToNodeStream has (abort) "signal" option,
-            // and we should wire it up to the SSR timeout below.
-            const helmetContext = {} as HelmetDataContext;
-            void prerenderToNodeStream(
-              <GlobalStateProvider
-                initialState={ssrContext.state}
-                ssrContext={ssrContext}
-              >
-                <StaticRouter location={req.url}>
-                  <HelmetProvider context={helmetContext}>
-                    <App2 />
-                  </HelmetProvider>
-                </StaticRouter>
-              </GlobalStateProvider>,
-              { onError: reject },
-            ).then((result) => {
-              ({ helmet } = helmetContext);
-              resolve(result.prelude);
-            }).catch(reject);
-          },
-        );
-
+        const renderPass = async () => new Promise((resolveArg, rejectArg) => {
+          ssrContext.chunks = [];
+
+          // NOTE: JS does not have problems if resolve() and reject() methods
+          // of a Promise are called multiple times, with different arguments;
+          // it only respects the first call, and ignores subsequent ones.
+          // We, however, really want to assert that here, to safeguard against
+          // any future problems due to unexpected internal changes in React,
+          // if any.
+          let error;
+          const resolve = arg => {
+            if (error !== undefined) throw Error('Internal error');
+            error = null;
+            resolveArg(arg);
+          };
+          const reject = arg => {
+            if (error !== undefined && error !== arg) {
+              throw Error('Internal error');
+            }
+            error = arg;
+            rejectArg(arg);
+          };
+
+          // TODO: prerenderToNodeStream has (abort) "signal" option,
+          // and we should wire it up to the SSR timeout below.
+          const helmetContext = {};
+          void prerenderToNodeStream(/*#__PURE__*/_jsx(GlobalStateProvider, {
+            initialState: ssrContext.state,
+            ssrContext: ssrContext,
+            children: /*#__PURE__*/_jsx(StaticRouter, {
+              location: req.url,
+              children: /*#__PURE__*/_jsx(HelmetProvider, {
+                context: helmetContext,
+                children: /*#__PURE__*/_jsx(App2, {})
+              })
+            })
+          }), {
+            onError: reject
+          }).then(result => {
+            ({
+              helmet
+            } = helmetContext);
+            resolve(result.prelude);
+          }).catch(reject);
+        });
         let ssrRound = 0;
         let bailed = false;
-        for (; ssrRound < ops.maxSsrRounds!; ++ssrRound) {
+        for (; ssrRound < ops.maxSsrRounds; ++ssrRound) {
           stream = await renderPass();
-
           if (!ssrContext.dirty) break;
-
-          const timeout = ops.ssrTimeout! + ssrStart - Date.now();
-          bailed = timeout <= 0 || !await Promise.race([
-            Promise.allSettled(ssrContext.pending),
-            timer(timeout).then(() => false),
-          ]);
+          const timeout = ops.ssrTimeout + ssrStart - Date.now();
+          bailed = timeout <= 0 || !(await Promise.race([Promise.allSettled(ssrContext.pending), timer(timeout).then(() => false)]));
           if (bailed) break;
         }
-
         let logMsg;
         if (ssrContext.dirty) {
           // NOTE: In the case of incomplete SSR one more round is necessary
           // to ensure the correct hydration when some pending promises have
           // resolved and placed their data into the initial global state.
           stream = await renderPass();
-
-          logMsg = bailed ? `SSR timed out after ${ops.ssrTimeout} second(s)`
-            : `SSR bailed out after ${ops.maxSsrRounds} round(s)`;
+          logMsg = bailed ? `SSR timed out after ${ops.ssrTimeout} second(s)` : `SSR bailed out after ${ops.maxSsrRounds} round(s)`;
         } else logMsg = `SSR completed in ${ssrRound + 1} round(s)`;
-
-        ops.logger!.log(ssrContext.dirty ? 'warn' : 'info', logMsg);
-
+        ops.logger.log(ssrContext.dirty ? 'warn' : 'info', logMsg);
         if (ssrContext.redirectTo) {
           res.redirect(ssrContext.status, ssrContext.redirectTo);
           return;
         }
-
-        await new Promise((ready) => {
-          stream!.pipe(new Writable({
+        await new Promise(ready => {
+          stream.pipe(new Writable({
             destroy: ready,
-            write: (chunk: { toString: () => string }, _, done) => {
+            write: (chunk, _, done) => {
               appHtmlMarkup += chunk.toString();
               done();
-            },
+            }
           }));
         });
       }
@@ -550,16 +420,13 @@ export default function factory(
       const payload = serializeJs({
         CHUNK_GROUPS: chunkGroups,
         CONFIG: configToInject ?? sanitizedConfig,
-        ISTATE: ssrContext.state,
+        ISTATE: ssrContext.state
       }, {
         ignoreFunction: true,
-        unsafe: true,
+        unsafe: true
       });
-      cipher.update(forge.util.createBuffer(payload, 'utf8'));
-      cipher.finish();
-      const INJ = forge.util.encode64(`${iv}${cipher.output.data}`);
-
-      const chunkSet = new Set<string>();
+      const INJ = Buffer.concat([iv, cipher.update(payload, 'utf8'), cipher.final()]).toString('base64');
+      const chunkSet = new Set();
 
       // TODO: "main" chunk has to be added explicitly,
       // because unlike all other chunks they are not managed by <CodeSplit>
@@ -569,35 +436,24 @@ export default function factory(
       // remove or add other entry points, but it requires additional
       // efforts to figure out how to automatically order them right,
       // thus for now this handles the default config.
-      [
-        'main',
-        ...ssrContext.chunks,
-      ].forEach((chunk) => {
+      ['main', ...ssrContext.chunks].forEach(chunk => {
         const assets = chunkGroups[chunk];
-        if (assets) assets.forEach((asset) => chunkSet.add(asset));
+        if (assets) assets.forEach(asset => chunkSet.add(asset));
       });
-
       let styleChunkString = '';
       let scriptChunkString = '';
-      chunkSet.forEach((chunk) => {
+      chunkSet.forEach(chunk => {
         if (chunk.endsWith('.css')) {
-          styleChunkString += `<link href="${publicPath as string}${chunk}" rel="stylesheet">`;
-        } else if (
-          chunk.endsWith('.js')
-          // In dev mode HMR adds JS updates into asset arrays,
-          // and they (updates) should be ignored.
-          && !chunk.endsWith('.hot-update.js')
-        ) {
-          scriptChunkString += `<script src="${publicPath as string}${chunk}" type="application/javascript"></script>`;
+          styleChunkString += `<link href="${publicPath}${chunk}" rel="stylesheet">`;
+        } else if (chunk.endsWith('.js')
+        // In dev mode HMR adds JS updates into asset arrays,
+        // and they (updates) should be ignored.
+        && !chunk.endsWith('.hot-update.js')) {
+          scriptChunkString += `<script src="${publicPath}${chunk}" type="application/javascript"></script>`;
         }
       });
-
       const grouppedExtraScripts = groupExtraScripts(extraScripts);
-
-      const faviconLink = ops.favicon
-        ? '<link rel="shortcut icon" href="/favicon.ico">'
-        : '';
-
+      const faviconLink = ops.favicon ? '<link rel="shortcut icon" href="/favicon.ico">' : '';
       const html = `<!DOCTYPE html>
         <html lang="en">
           <head>
@@ -622,22 +478,20 @@ export default function factory(
             ${grouppedExtraScripts[SCRIPT_LOCATIONS.DEFAULT]}
           </body>
         </html>`;
-
       const status = ssrContext.status || 200;
       if (status !== 200) res.status(status);
-
       if (cacheRef && status < 500) {
         // Note: waiting for the caching to complete is not strictly necessary,
         // but it greately simplifies testing, and error reporting.
-        await new Promise<void>((done, failed) => {
+        await new Promise((done, failed) => {
           brotliCompress(html, (error, buffer) => {
-            if (error) failed(error);
-            else {
-              const b = buffer as unknown as BufferWithNonce;
-              b.nonce = (req as unknown as {
-                nonce: string;
-              }).nonce;
-              cache!.add({ buffer: b, status }, cacheRef.key, buffer.length);
+            if (error) failed(error);else {
+              const b = buffer;
+              b.nonce = req.nonce;
+              cache.add({
+                buffer: b,
+                status
+              }, cacheRef.key, buffer.length);
               done();
             }
           });
@@ -653,3 +507,4 @@ export default function factory(
     }
   };
 }
+//# sourceMappingURL=renderer.js.map