@anansi/core 0.16.24 → 0.16.26

package/lib/scripts/scripts/startDevserver.js

@@ -0,0 +1,234 @@
+#!/usr/bin/env node
+Object.hasOwn = Object.hasOwn || /* istanbul ignore next */function hasOwn(it, key) {
+  return Object.prototype.hasOwnProperty.call(it, key);
+};
+import diskFs from 'fs';
+import { createFsRequire } from 'fs-require';
+import { createFsFromVolume, Volume } from 'memfs';
+import path from 'path';
+import sourceMapSupport from 'source-map-support';
+import tmp from 'tmp';
+import { ufs } from 'unionfs';
+import { promisify } from 'util';
+import webpack from 'webpack';
+import logging from 'webpack/lib/logging/runtime.js';
+import WebpackDevServer from 'webpack-dev-server';
+import 'cross-fetch/dist/node-polyfill.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: start-anansi <entrypoint-file>`);
+    process.exit(-1);
+  }
+  startDevServer(entrypoint);
+}
+let serverFileContents = Promise.resolve('');
+let serverEntry = '';
+export default async function startDevServer(entrypoint, env = {}) {
+  var _webpackConfigs$, _webpackConfigs$$devS;
+  const webpackConfig = await getWebpackConfig();
+  const log = logging.getLogger('anansi-devserver');
+
+  // Set up in memory filesystem
+  const volume = new Volume();
+  const fs = createFsFromVolume(volume);
+  ufs.use(diskFs).use(fs);
+  const fsRequire = createFsRequire(ufs);
+  const readFile = promisify(ufs.readFile);
+  let server;
+
+  // Generate a temporary file so we can hot reload from the root of the application
+  function hotEntry(entryPath) {
+    // eslint-disable-next-line
+    // @ts-ignore for some reason it's not picking up that other options are optional
+    const generatedEntrypoint = tmp.fileSync({
+      postfix: '.js'
+    });
+    diskFs.writeSync(generatedEntrypoint.fd, `
+  import entry from "${path.resolve(process.cwd(), entryPath)}";
+
+  if (import.meta.webpackHot) {
+    import.meta.webpackHot.accept();
+  }
+
+  export default entry;
+    `);
+    return generatedEntrypoint;
+  }
+  const webpackConfigs = [webpackConfig({
+    ...env,
+    entrypath: hotEntry(entrypoint).name,
+    name: 'client'
+  }, {
+    mode: 'development'
+  }), webpackConfig({
+    ...env,
+    entrypath: entrypoint.replace('.tsx', '.server.tsx'),
+    name: 'server',
+    BROWSERSLIST_ENV: 'current node'
+  }, {
+    mode: 'development',
+    target: 'node'
+  })];
+
+  // initialize the webpack compiler
+  const compiler = webpack(webpackConfigs);
+  sourceMapSupport.install({
+    hookRequire: true
+  });
+  function getServerBundle(serverStats) {
+    var _serverJson$outputPat;
+    const serverJson = serverStats.toJson({
+      assets: true
+    });
+    return path.join((_serverJson$outputPat = serverJson.outputPath) != null ? _serverJson$outputPat : '', 'server.js');
+  }
+  function handleErrors(fn) {
+    return async function (req, res, next) {
+      try {
+        return await fn(req, res);
+      } catch (x) {
+        next(x);
+      }
+    };
+  }
+  let initRender = [];
+  let render = (...args) => new Promise(resolve => {
+    var _initRender;
+    (_initRender = initRender) == null ? void 0 : _initRender.push({
+      args,
+      resolve
+    });
+  });
+  function importRender(stats) {
+    var _clientStats$compilat, _clientStats$compilat2, _serverStats$compilat, _serverStats$compilat2;
+    const [clientStats, serverStats] = stats;
+    if (clientStats != null && (_clientStats$compilat = clientStats.compilation) != null && (_clientStats$compilat2 = _clientStats$compilat.errors) != null && _clientStats$compilat2.length || serverStats != null && (_serverStats$compilat = serverStats.compilation) != null && (_serverStats$compilat2 = _serverStats$compilat.errors) != null && _serverStats$compilat2.length) {
+      log.error('Errors for client build: ' + clientStats.compilation.errors);
+      log.error('Errors for server build: ' + serverStats.compilation.errors);
+      // first time, rather than re-render
+      if (Array.isArray(initRender)) {
+        process.exit(-1);
+      }
+      log.error('Above compiler errors blocking reload');
+      return;
+    } else {
+      log.info('Launching SSR');
+    }
+
+    // ASSETS
+    const clientManifest = clientStats.toJson();
+    serverEntry = getServerBundle(serverStats);
+    serverFileContents = readFile(serverEntry).then(buf => buf.toString());
+    // reload modules
+    Object.keys(fsRequire.cache).forEach(key => {
+      delete fsRequire.cache[key];
+    });
+    render = fsRequire(serverEntry).default.bind(undefined, clientManifest);
+    // SERVER SIDE ENTRYPOINT
+    if (Array.isArray(initRender)) {
+      initRender.forEach(async init => {
+        try {
+          log.info('Resolving queued requests');
+          await render(...init.args);
+          init.resolve();
+        } catch (e) {
+          log.error('Error when attempting to render queued requests');
+          log.error(e);
+        }
+      });
+      initRender = undefined;
+    }
+  }
+  const devServer = new WebpackDevServer(
+  // write to memory filesystem so we can import
+  {
+    ...webpackConfigs[0].devServer,
+    devMiddleware: {
+      ...((_webpackConfigs$ = webpackConfigs[0]) == null ? void 0 : (_webpackConfigs$$devS = _webpackConfigs$.devServer) == null ? void 0 : _webpackConfigs$$devS.devMiddleware),
+      outputFileSystem: {
+        ...fs,
+        join: path.join
+      }
+    },
+    setupMiddlewares: (middlewares, devServer) => {
+      var _webpackConfigs$0$dev, _webpackConfigs$0$dev2, _devServer$app, _webpackConfigs$0$dev3;
+      if (!devServer) {
+        throw new Error('webpack-dev-server is not defined');
+      }
+      const otherRoutes = [process.env.WEBPACK_PUBLIC_PATH, ...Object.keys((_webpackConfigs$0$dev = (_webpackConfigs$0$dev2 = webpackConfigs[0].devServer) == null ? void 0 : _webpackConfigs$0$dev2.proxy) != null ? _webpackConfigs$0$dev : {})];
+      // serve SSR for non-WEBPACK_PUBLIC_PATH
+      (_devServer$app = devServer.app) == null ? void 0 : _devServer$app.get(new RegExp(`^(?!${otherRoutes.join('|')})`), 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 => {
+          log.error('Fatal:', error);
+          if (error.code === 'ECONNRESET') {
+            log.error('ECONNRESET is usually due to browser closing the connection');
+          }
+        });
+        await render(req, res);
+      }));
+      if ((_webpackConfigs$0$dev3 = webpackConfigs[0].devServer) != null && _webpackConfigs$0$dev3.setupMiddlewares) {
+        return webpackConfigs[0].devServer.setupMiddlewares(middlewares, devServer);
+      }
+      return middlewares;
+    }
+  }, compiler);
+  const runServer = async () => {
+    await devServer.start();
+    devServer.compiler.hooks.done.tap('Anansi Server', multiStats => {
+      if (!multiStats) {
+        log.error('stats not send');
+        process.exit(-1);
+      }
+      if (!Object.hasOwn(multiStats, 'stats')) return;
+      if (multiStats.stats.length > 1) {
+        try {
+          importRender(multiStats.stats);
+        } catch (e) {
+          log.error('Failed to load serve entrypoint');
+          const finder = new RegExp(`${serverEntry}:([\\d]+):([\\d]+)`, 'g');
+          serverFileContents.then(fileText => {
+            const textRows = fileText.split('\n');
+            log.error('>>> Stack Context [serve entrypoint] <<<');
+            for (const match of (_e$stack$matchAll = e.stack.matchAll(finder)) != null ? _e$stack$matchAll : []) {
+              var _e$stack$matchAll;
+              const row = Number.parseInt(match[1]);
+              const col = Number.parseInt(match[2]);
+              log.error(path.basename(serverEntry) + ' ' + row + ':' + col);
+              log.error(textRows[row - 2]);
+              log.error(textRows[row - 1]);
+              log.error(Array(col).join(' ') + '^');
+              log.error(textRows[row]);
+              log.error(textRows[row + 1]);
+              log.error(textRows[row + 2]);
+            }
+            diskFs.writeFileSync(serverEntry, fileText);
+          });
+          throw e;
+        }
+      } else {
+        log.error('Only compiler one stat');
+      }
+    });
+  };
+  const stopServer = async () => {
+    log.info('Stopping server...');
+    await devServer.stop();
+    log.info('Server closed');
+  };
+  process.on('SIGINT', () => {
+    log.warn('Received SIGINT, devserver shutting down');
+    stopServer();
+    process.exit(-1);
+  });
+  runServer();
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["Object","hasOwn","it","key","prototype","hasOwnProperty","call","diskFs","createFsRequire","createFsFromVolume","Volume","path","sourceMapSupport","tmp","ufs","promisify","webpack","logging","WebpackDevServer","getWebpackConfig","import","meta","entrypoint","process","argv","console","log","exit","startDevServer","serverFileContents","Promise","resolve","serverEntry","env","_webpackConfigs$","_webpackConfigs$$devS","webpackConfig","getLogger","volume","fs","use","fsRequire","readFile","server","hotEntry","entryPath","generatedEntrypoint","fileSync","postfix","writeSync","fd","cwd","webpackConfigs","entrypath","name","mode","replace","BROWSERSLIST_ENV","target","compiler","install","hookRequire","getServerBundle","serverStats","_serverJson$outputPat","serverJson","toJson","assets","join","outputPath","handleErrors","fn","req","res","next","x","initRender","render","args","_initRender","push","importRender","stats","_clientStats$compilat","_clientStats$compilat2","_serverStats$compilat","_serverStats$compilat2","clientStats","compilation","errors","length","error","Array","isArray","info","clientManifest","then","buf","toString","keys","cache","forEach","default","bind","undefined","init","e","devServer","devMiddleware","outputFileSystem","setupMiddlewares","middlewares","_webpackConfigs$0$dev","_webpackConfigs$0$dev2","_devServer$app","_webpackConfigs$0$dev3","Error","otherRoutes","WEBPACK_PUBLIC_PATH","proxy","app","get","RegExp","url","endsWith","statusCode","setHeader","send","socket","on","code","runServer","start","hooks","done","tap","multiStats","finder","fileText","textRows","split","match","_e$stack$matchAll","stack","matchAll","row","Number","parseInt","col","basename","writeFileSync","stopServer","stop","warn"],"sources":["../../../src/scripts/startDevserver.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 type { NextFunction } from 'express';\nimport diskFs from 'fs';\nimport { createFsRequire } from 'fs-require';\nimport { Server, IncomingMessage, ServerResponse } from 'http';\nimport { createFsFromVolume, Volume } from 'memfs';\nimport path from 'path';\nimport sourceMapSupport from 'source-map-support';\nimport tmp from 'tmp';\nimport { ufs } from 'unionfs';\nimport { promisify } from 'util';\nimport webpack, { MultiCompiler } from 'webpack';\nimport logging from 'webpack/lib/logging/runtime.js';\nimport WebpackDevServer from 'webpack-dev-server';\n\nimport 'cross-fetch/dist/node-polyfill.js';\nimport { getWebpackConfig } from './getWebpackConfig.js';\nimport { BoundRender } 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: start-anansi <entrypoint-file>`);\n    process.exit(-1);\n  }\n\n  startDevServer(entrypoint);\n}\n\nlet serverFileContents: Promise<string> = Promise.resolve('');\nlet serverEntry = '';\n\nexport default async function startDevServer(\n  entrypoint: string,\n  env: Record<string, unknown> = {},\n) {\n  const webpackConfig = await getWebpackConfig();\n\n  const log = logging.getLogger('anansi-devserver');\n\n  // Set up in memory filesystem\n  const volume = new Volume();\n  const fs = createFsFromVolume(volume);\n  ufs.use(diskFs).use(fs as any);\n\n  const fsRequire = createFsRequire(ufs);\n  const readFile = promisify(ufs.readFile);\n  let server: Server | undefined;\n\n  // Generate a temporary file so we can hot reload from the root of the application\n  function hotEntry(entryPath: string) {\n    // eslint-disable-next-line\n    // @ts-ignore for some reason it's not picking up that other options are optional\n    const generatedEntrypoint = tmp.fileSync({ postfix: '.js' });\n    diskFs.writeSync(\n      generatedEntrypoint.fd,\n      `\n  import entry from \"${path.resolve(process.cwd(), entryPath)}\";\n\n  if (import.meta.webpackHot) {\n    import.meta.webpackHot.accept();\n  }\n\n  export default entry;\n    `,\n    );\n    return generatedEntrypoint;\n  }\n\n  const webpackConfigs = [\n    webpackConfig(\n      {\n        ...env,\n        entrypath: hotEntry(entrypoint).name,\n        name: 'client',\n      },\n      { mode: 'development' },\n    ),\n    webpackConfig(\n      {\n        ...env,\n        entrypath: entrypoint.replace('.tsx', '.server.tsx'),\n        name: 'server',\n        BROWSERSLIST_ENV: 'current node',\n      },\n      { mode: 'development', target: 'node' },\n    ),\n  ] as const;\n\n  // initialize the webpack compiler\n  const compiler: MultiCompiler = webpack(webpackConfigs);\n\n  sourceMapSupport.install({ hookRequire: true });\n\n  function getServerBundle(serverStats: webpack.Stats) {\n    const serverJson = serverStats.toJson({ assets: true });\n    return path.join(serverJson.outputPath ?? '', 'server.js');\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  let initRender:\n    | { args: Parameters<BoundRender>; resolve: () => void }[]\n    | undefined = [];\n  let render: BoundRender = (...args) =>\n    new Promise(resolve => {\n      initRender?.push({ args, resolve });\n    });\n\n  function importRender(stats: webpack.Stats[]) {\n    const [clientStats, serverStats] = stats;\n    if (\n      clientStats?.compilation?.errors?.length ||\n      serverStats?.compilation?.errors?.length\n    ) {\n      log.error('Errors for client build: ' + clientStats.compilation.errors);\n      log.error('Errors for server build: ' + serverStats.compilation.errors);\n      // first time, rather than re-render\n      if (Array.isArray(initRender)) {\n        process.exit(-1);\n      }\n      log.error('Above compiler errors blocking reload');\n      return;\n    } else {\n      log.info('Launching SSR');\n    }\n\n    // ASSETS\n    const clientManifest = clientStats.toJson();\n\n    serverEntry = getServerBundle(serverStats);\n    serverFileContents = readFile(serverEntry).then(buf => buf.toString());\n    // reload modules\n    Object.keys(fsRequire.cache).forEach(key => {\n      delete fsRequire.cache[key];\n    });\n    render = (fsRequire(serverEntry) as any).default.bind(\n      undefined,\n      clientManifest,\n    );\n    // SERVER SIDE ENTRYPOINT\n    if (Array.isArray(initRender)) {\n      initRender.forEach(async init => {\n        try {\n          log.info('Resolving queued requests');\n          await render(...init.args);\n          init.resolve();\n        } catch (e) {\n          log.error('Error when attempting to render queued requests');\n          log.error(e);\n        }\n      });\n      initRender = undefined;\n    }\n  }\n\n  const devServer = new WebpackDevServer(\n    // write to memory filesystem so we can import\n    {\n      ...webpackConfigs[0].devServer,\n      devMiddleware: {\n        ...webpackConfigs[0]?.devServer?.devMiddleware,\n        outputFileSystem: {\n          ...fs,\n          join: path.join as any,\n        } as any,\n      },\n      setupMiddlewares: (middlewares, devServer) => {\n        if (!devServer) {\n          throw new Error('webpack-dev-server is not defined');\n        }\n\n        const otherRoutes = [\n          process.env.WEBPACK_PUBLIC_PATH,\n          ...Object.keys(webpackConfigs[0].devServer?.proxy ?? {}),\n        ];\n        // serve SSR for non-WEBPACK_PUBLIC_PATH\n        devServer.app?.get(\n          new RegExp(`^(?!${otherRoutes.join('|')})`),\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              log.error('Fatal:', error);\n              if ((error as any).code === 'ECONNRESET') {\n                log.error(\n                  'ECONNRESET is usually due to browser closing the connection',\n                );\n              }\n            });\n\n            await render(req, res);\n          }),\n        );\n\n        if (webpackConfigs[0].devServer?.setupMiddlewares) {\n          return webpackConfigs[0].devServer.setupMiddlewares(\n            middlewares,\n            devServer,\n          );\n        }\n\n        return middlewares;\n      },\n    },\n    compiler,\n  );\n  const runServer = async () => {\n    await devServer.start();\n    devServer.compiler.hooks.done.tap(\n      'Anansi Server',\n      (multiStats: webpack.MultiStats | webpack.Stats) => {\n        if (!multiStats) {\n          log.error('stats not send');\n          process.exit(-1);\n        }\n\n        if (!Object.hasOwn(multiStats, 'stats')) return;\n        if ((multiStats as webpack.MultiStats).stats.length > 1) {\n          try {\n            importRender((multiStats as webpack.MultiStats).stats);\n          } catch (e: any) {\n            log.error('Failed to load serve entrypoint');\n            const finder = new RegExp(`${serverEntry}:([\\\\d]+):([\\\\d]+)`, 'g');\n            serverFileContents.then(fileText => {\n              const textRows = fileText.split('\\n');\n              log.error('>>> Stack Context [serve entrypoint] <<<');\n              for (const match of e.stack.matchAll(finder) ?? []) {\n                const row = Number.parseInt(match[1]);\n                const col = Number.parseInt(match[2]);\n                log.error(path.basename(serverEntry) + ' ' + row + ':' + col);\n                log.error(textRows[row - 2]);\n                log.error(textRows[row - 1]);\n                log.error(Array(col).join(' ') + '^');\n                log.error(textRows[row]);\n                log.error(textRows[row + 1]);\n                log.error(textRows[row + 2]);\n              }\n              diskFs.writeFileSync(serverEntry, fileText);\n            });\n\n            throw e;\n          }\n        } else {\n          log.error('Only compiler one stat');\n        }\n      },\n    );\n  };\n  const stopServer = async () => {\n    log.info('Stopping server...');\n    await devServer.stop();\n    log.info('Server closed');\n  };\n\n  process.on('SIGINT', () => {\n    log.warn('Received SIGINT, devserver shutting down');\n    stopServer();\n    process.exit(-1);\n  });\n\n  runServer();\n}\n"],"mappings":"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"}

package/lib/scripts/scripts/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3NjcmlwdHMvdHlwZXMudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUmVxdWVzdCwgUmVzcG9uc2UgfSBmcm9tICdleHByZXNzJztcbmltcG9ydCB7IFNlcnZlclJlc3BvbnNlLCBJbmNvbWluZ01lc3NhZ2UgfSBmcm9tICdodHRwJztcbmltcG9ydCB7IFN0YXRzQ29tcGlsYXRpb24gfSBmcm9tICd3ZWJwYWNrJztcblxuZXhwb3J0IHR5cGUgUmVuZGVyID0gKFxuICBjbGllbnRNYW5pZmVzdDogU3RhdHNDb21waWxhdGlvbixcbiAgcmVxOiBSZXF1ZXN0IHwgSW5jb21pbmdNZXNzYWdlLFxuICByZXM6IFJlc3BvbnNlIHwgU2VydmVyUmVzcG9uc2UsXG4pID0+IFByb21pc2U8dm9pZD47XG5cbmV4cG9ydCB0eXBlIEJvdW5kUmVuZGVyID0gKFxuICByZXE6IFJlcXVlc3QgfCBJbmNvbWluZ01lc3NhZ2UsXG4gIHJlczogUmVzcG9uc2UgfCBTZXJ2ZXJSZXNwb25zZSxcbikgPT4gUHJvbWlzZTx2b2lkPjtcbiJdLCJtYXBwaW5ncyI6IiJ9

package/lib/scripts/spouts/DocumentComponent.js

@@ -0,0 +1,43 @@
+import _jsx from "@babel/runtime/helpers/jsx";
+var _process$env$WEBPACK_;
+import React from "react";
+export default function Document({
+  assets,
+  head,
+  children,
+  title,
+  rootId,
+  charSet,
+  scripts,
+  extraStyle
+}) {
+  return /*#__PURE__*/_jsx("html", {}, void 0, /*#__PURE__*/_jsx("head", {}, void 0, /*#__PURE__*/_jsx("meta", {
+    charSet: charSet
+  }), head, extraStyle, assets.map((asset, i) => /*#__PURE__*/React.createElement("link", {
+    key: i,
+    rel: "preload",
+    ...asset
+  })), /*#__PURE__*/_jsx("title", {}, void 0, title)), /*#__PURE__*/_jsx("body", {}, void 0, /*#__PURE__*/_jsx("div", {
+    id: rootId
+  }, void 0, children), scripts, assets.filter(({
+    href
+  }) => href.endsWith('.js')).map(({
+    href
+  }, i) => /*#__PURE__*/_jsx("script", {
+    src: href,
+    async: true
+  }, i))));
+}
+Document.defaultProps = {
+  head: /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/_jsx("meta", {
+    name: "viewport",
+    content: "width=device-width, initial-scale=1"
+  }), /*#__PURE__*/_jsx("link", {
+    rel: "shortcut icon",
+    href: `${(_process$env$WEBPACK_ = process.env.WEBPACK_PUBLIC_PATH) != null ? _process$env$WEBPACK_ : '/'}favicon.ico`
+  })),
+  charSet: 'utf-8',
+  rootId: 'anansi-root',
+  scripts: null
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/scripts/spouts/antd.server.js

@@ -0,0 +1,33 @@
+import _jsx from "@babel/runtime/helpers/jsx";
+import React from 'react';
+export default function antdSpout() {
+  return next => async props => {
+    var _nextProps$scripts;
+    const {
+      createCache,
+      extractStyle,
+      StyleProvider
+    } = await import('@ant-design/cssinjs');
+    const cache = createCache();
+    const nextProps = await next(props);
+    const scripts = (_nextProps$scripts = nextProps.scripts) != null ? _nextProps$scripts : [];
+    const AntdSheets = () => {
+      return /*#__PURE__*/_jsx("script", {
+        dangerouslySetInnerHTML: {
+          __html: `</script>${extractStyle(cache)}<script>`
+        }
+      });
+    };
+    // unfortunately we have to inject this after the entire content has streamed in or it doesn't correctly populate
+    // see: https://github.com/ant-design/cssinjs/issues/79
+    scripts.push( /*#__PURE__*/_jsx(AntdSheets, {}));
+    return {
+      ...nextProps,
+      app: /*#__PURE__*/_jsx(StyleProvider, {
+        cache: cache
+      }, void 0, nextProps.app),
+      scripts
+    };
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/scripts/spouts/app.js

@@ -0,0 +1,6 @@
+const appSpout = app => props => Promise.resolve({
+  ...props,
+  app
+});
+export default appSpout;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJhcHBTcG91dCIsImFwcCIsInByb3BzIiwiUHJvbWlzZSIsInJlc29sdmUiXSwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc3BvdXRzL2FwcC50c3giXSwic291cmNlc0NvbnRlbnQiOlsiY29uc3QgYXBwU3BvdXQgPVxuICAoYXBwOiBKU1guRWxlbWVudCkgPT5cbiAgPFAgZXh0ZW5kcyBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPj4ocHJvcHM6IFApID0+XG4gICAgUHJvbWlzZS5yZXNvbHZlKHsgLi4ucHJvcHMsIGFwcCB9KTtcblxuZXhwb3J0IGRlZmF1bHQgYXBwU3BvdXQ7XG4iXSwibWFwcGluZ3MiOiJBQUFBLE1BQU1BLFFBQVEsR0FDWEMsR0FBZ0IsSUFDbUJDLEtBQVEsSUFDMUNDLE9BQU8sQ0FBQ0MsT0FBTyxDQUFDO0VBQUUsR0FBR0YsS0FBSztFQUFFRDtBQUFJLENBQUMsQ0FBQztBQUV0QyxlQUFlRCxRQUFRIn0=

package/lib/scripts/spouts/app.server.js

@@ -0,0 +1,6 @@
+const appSpout = app => props => Promise.resolve({
+  ...props,
+  app
+});
+export default appSpout;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJhcHBTcG91dCIsImFwcCIsInByb3BzIiwiUHJvbWlzZSIsInJlc29sdmUiXSwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc3BvdXRzL2FwcC5zZXJ2ZXIudHN4Il0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFNlcnZlclByb3BzIH0gZnJvbSAnLi90eXBlcy5qcyc7XG5cbmNvbnN0IGFwcFNwb3V0ID1cbiAgKGFwcDogSlNYLkVsZW1lbnQpID0+XG4gIDxQIGV4dGVuZHMgU2VydmVyUHJvcHM+KHByb3BzOiBQKSA9PlxuICAgIFByb21pc2UucmVzb2x2ZSh7IC4uLnByb3BzLCBhcHAgfSk7XG5cbmV4cG9ydCBkZWZhdWx0IGFwcFNwb3V0O1xuIl0sIm1hcHBpbmdzIjoiQUFFQSxNQUFNQSxRQUFRLEdBQ1hDLEdBQWdCLElBQ09DLEtBQVEsSUFDOUJDLE9BQU8sQ0FBQ0MsT0FBTyxDQUFDO0VBQUUsR0FBR0YsS0FBSztFQUFFRDtBQUFJLENBQUMsQ0FBQztBQUV0QyxlQUFlRCxRQUFRIn0=

package/lib/scripts/spouts/csp.js

@@ -0,0 +1,27 @@
+// TODO: memoize this
+export function buildPolicy(policyObj) {
+  return Object.keys(policyObj).map(key => {
+    const val = Array.isArray(policyObj[key]) ? [...new Set(policyObj[key]).values()].filter(v => v).join(' ') : policyObj[key];
+
+    // move strict dynamic to the end of the policy if it exists to be backwards compatible with csp2
+    // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/script-src#strict-dynamic
+    if (typeof val === 'string' && val.includes("'strict-dynamic'")) {
+      const newVal = `${val.replace(/\s?'strict-dynamic'\s?/gi, ' ').trim()} 'strict-dynamic'`;
+      return `${key} ${newVal}`;
+    }
+    return `${key} ${val}`;
+  }).join('; ');
+}
+export function joinNonce(policyObj, nonce) {
+  if (!nonce) return policyObj;
+  const policy = {
+    ...policyObj
+  };
+  if (typeof policy['script-src'] === 'string') {
+    policy['script-src'] = [policy['script-src'], `'nonce-${nonce}'`];
+  } else {
+    policy['script-src'] = [...policy['script-src'], `'nonce-${nonce}'`];
+  }
+  return policy;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/scripts/spouts/document.js

@@ -0,0 +1,7 @@
+export default function documentSpout(options) {
+  return next => async props => {
+    const nextProps = await next(props);
+    return nextProps;
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJkb2N1bWVudFNwb3V0Iiwib3B0aW9ucyIsIm5leHQiLCJwcm9wcyIsIm5leHRQcm9wcyJdLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zcG91dHMvZG9jdW1lbnQudHN4Il0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBSZWFjdCBmcm9tICdyZWFjdCc7XG5cbmltcG9ydCB0eXBlIHsgQ2xpZW50U3BvdXQgfSBmcm9tICcuL3R5cGVzLmpzJztcblxuZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24gZG9jdW1lbnRTcG91dChvcHRpb25zOiB7XG4gIGhlYWQ/OiBSZWFjdC5SZWFjdE5vZGU7XG4gIHRpdGxlOiBzdHJpbmc7XG59KTogQ2xpZW50U3BvdXQge1xuICByZXR1cm4gbmV4dCA9PiBhc3luYyBwcm9wcyA9PiB7XG4gICAgY29uc3QgbmV4dFByb3BzID0gYXdhaXQgbmV4dChwcm9wcyk7XG5cbiAgICByZXR1cm4gbmV4dFByb3BzO1xuICB9O1xufVxuIl0sIm1hcHBpbmdzIjoiQUFJQSxlQUFlLFNBQVNBLGFBQWFBLENBQUNDLE9BR3JDLEVBQWU7RUFDZCxPQUFPQyxJQUFJLElBQUksTUFBTUMsS0FBSyxJQUFJO0lBQzVCLE1BQU1DLFNBQVMsR0FBRyxNQUFNRixJQUFJLENBQUNDLEtBQUssQ0FBQztJQUVuQyxPQUFPQyxTQUFTO0VBQ2xCLENBQUM7QUFDSCJ9

package/lib/scripts/spouts/document.server.js

@@ -0,0 +1,63 @@
+import React from 'react';
+import { buildPolicy, joinNonce } from './csp.js';
+import Document from './DocumentComponent.js';
+export default function DocumentSpout(options) {
+  return next => async props => {
+    var _props$clientManifest, _props$clientManifest2, _props$clientManifest3, _props$clientManifest4, _props$clientManifest5, _nextProps$title;
+    const nextProps = await next(props);
+    const publicPath = props.clientManifest.publicPath;
+    if (Object.keys((_props$clientManifest = (_props$clientManifest2 = props.clientManifest) == null ? void 0 : _props$clientManifest2.entrypoints) != null ? _props$clientManifest : {}).length < 1 || publicPath === undefined) throw new Error('Manifest missing entries needed');
+
+    // TODO: consider using this package for build stats in future:
+    // https://github.com/facebook/react/tree/main/packages/react-server-dom-webpack
+    const assetMap = assets => assets.map(({
+      name
+    }) => `${publicPath}${name}`);
+    const assetList = [];
+    Object.values((_props$clientManifest3 = (_props$clientManifest4 = props.clientManifest) == null ? void 0 : _props$clientManifest4.entrypoints) != null ? _props$clientManifest3 : {}).forEach(entrypoint => {
+      var _entrypoint$assets;
+      assetList.push(...assetMap((_entrypoint$assets = entrypoint.assets) != null ? _entrypoint$assets : []));
+    });
+    new Set(assetMap(Object.values((_props$clientManifest5 = props.clientManifest.namedChunkGroups) != null ? _props$clientManifest5 : {}).filter(({
+      name
+    }) => nextProps.matchedRoutes.some(route => name == null ? void 0 : name.includes(route.name))).flatMap(chunk => {
+      var _chunk$assets;
+      return [...((_chunk$assets = chunk.assets) != null ? _chunk$assets : []),
+      // any chunk preloads
+      ...childrenAssets(chunk)];
+    }))).forEach(asset => assetList.push(asset));
+
+    // find additional assets to preload based on matched route
+    const assets = assetList.filter(asset => !asset.endsWith('.hot-update.js')).map(asset => asset.endsWith('.css') ? {
+      href: asset,
+      rel: 'stylesheet'
+    } : asset.endsWith('.js') ? {
+      href: asset,
+      as: 'script'
+    } : {
+      href: asset
+    });
+    if (options.csPolicy) {
+      const httpEquiv = process.env.NODE_ENV === 'production' ? 'Content-Security-Policy' : 'Content-Security-Policy-Report-Only';
+      props.res.setHeader(httpEquiv, buildPolicy(joinNonce(options.csPolicy, props.nonce)));
+    }
+    return {
+      ...nextProps,
+      app: /*#__PURE__*/React.createElement(Document, {
+        ...options,
+        extraStyle: nextProps.extraStyle,
+        title: (_nextProps$title = nextProps.title) != null ? _nextProps$title : options.title,
+        assets: assets,
+        rootId: options.rootId,
+        scripts: nextProps.scripts
+      }, nextProps.app)
+    };
+  };
+}
+function childrenAssets(chunk) {
+  return chunk.children ? Object.values(chunk.children).flatMap(preload => preload.flatMap(c => {
+    var _c$assets;
+    return (_c$assets = c.assets) != null ? _c$assets : [];
+  })) : [];
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","buildPolicy","joinNonce","Document","DocumentSpout","options","next","props","_props$clientManifest","_props$clientManifest2","_props$clientManifest3","_props$clientManifest4","_props$clientManifest5","_nextProps$title","nextProps","publicPath","clientManifest","Object","keys","entrypoints","length","undefined","Error","assetMap","assets","map","name","assetList","values","forEach","entrypoint","_entrypoint$assets","push","Set","namedChunkGroups","filter","matchedRoutes","some","route","includes","flatMap","chunk","_chunk$assets","childrenAssets","asset","endsWith","href","rel","as","csPolicy","httpEquiv","process","env","NODE_ENV","res","setHeader","nonce","app","createElement","extraStyle","title","rootId","scripts","children","preload","c","_c$assets"],"sources":["../../../src/spouts/document.server.tsx"],"sourcesContent":["import type { Route } from '@anansi/router';\nimport { Request } from 'express';\nimport React from 'react';\nimport { StatsChunkGroup } from 'webpack';\n\nimport { buildPolicy, joinNonce, Policy } from './csp.js';\nimport Document from './DocumentComponent.js';\nimport type { ServerSpout } from './types.js';\n\ntype NeededNext = {\n  matchedRoutes: Route<any>[];\n  title?: string;\n  scripts?: React.ReactNode[];\n  extraStyle?: React.ReactNode[];\n};\n\nexport default function DocumentSpout(options: {\n  head?: React.ReactNode;\n  title: string;\n  rootId?: string;\n  charSet?: string;\n  csPolicy?: Policy;\n}): ServerSpout<Record<string, unknown>, Record<string, unknown>, NeededNext> {\n  return next => async props => {\n    const nextProps = await next(props);\n\n    const publicPath = props.clientManifest.publicPath;\n\n    if (\n      Object.keys(props.clientManifest?.entrypoints ?? {}).length < 1 ||\n      publicPath === undefined\n    )\n      throw new Error('Manifest missing entries needed');\n\n    // TODO: consider using this package for build stats in future:\n    // https://github.com/facebook/react/tree/main/packages/react-server-dom-webpack\n    const assetMap = (assets: { name: string; size?: number }[]) =>\n      assets.map(({ name }) => `${publicPath}${name}`);\n\n    const assetList: string[] = [];\n    Object.values(props.clientManifest?.entrypoints ?? {}).forEach(\n      entrypoint => {\n        assetList.push(...assetMap(entrypoint.assets ?? []));\n      },\n    );\n    new Set(\n      assetMap(\n        Object.values(props.clientManifest.namedChunkGroups ?? {})\n          .filter(({ name }) =>\n            nextProps.matchedRoutes.some(route => name?.includes(route.name)),\n          )\n          .flatMap(chunk => [\n            ...(chunk.assets ?? []),\n            // any chunk preloads\n            ...childrenAssets(chunk),\n          ]),\n      ),\n    ).forEach(asset => assetList.push(asset));\n\n    // find additional assets to preload based on matched route\n    const assets: {\n      href: string;\n      as?: string | undefined;\n      rel?: string | undefined;\n    }[] = assetList\n      .filter(asset => !asset.endsWith('.hot-update.js'))\n      .map(asset =>\n        asset.endsWith('.css')\n          ? { href: asset, rel: 'stylesheet' }\n          : asset.endsWith('.js')\n          ? { href: asset, as: 'script' }\n          : { href: asset },\n      );\n\n    if (options.csPolicy) {\n      const httpEquiv =\n        process.env.NODE_ENV === 'production'\n          ? 'Content-Security-Policy'\n          : 'Content-Security-Policy-Report-Only';\n\n      props.res.setHeader(\n        httpEquiv,\n        buildPolicy(joinNonce(options.csPolicy, props.nonce)),\n      );\n    }\n\n    return {\n      ...nextProps,\n      app: (\n        <Document\n          {...options}\n          extraStyle={nextProps.extraStyle}\n          title={nextProps.title ?? options.title}\n          assets={assets}\n          rootId={options.rootId}\n          scripts={nextProps.scripts}\n        >\n          {nextProps.app}\n        </Document>\n      ),\n    };\n  };\n}\n\nfunction childrenAssets(chunk: StatsChunkGroup) {\n  return chunk.children\n    ? Object.values(chunk.children).flatMap(preload =>\n        preload.flatMap(c => c.assets ?? []),\n      )\n    : [];\n}\n"],"mappings":"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"}

package/lib/scripts/spouts/json.js

@@ -0,0 +1,34 @@
+export default function JSONSpout({
+  id = 'anansi-json'
+} = {}) {
+  return next => async props => {
+    const getInitialData = key => {
+      const globalId = `${id}.${key}`;
+      return new Promise((resolve, reject) => {
+        let el;
+        if (el = document.getElementById(globalId)) {
+          resolve(getDataFromEl(el, globalId));
+          return;
+        }
+        document.addEventListener('DOMContentLoaded', () => {
+          el = document.getElementById(globalId);
+          if (el) resolve(getDataFromEl(el, globalId));else reject(new Error(`failed to find DOM with ${key} state`));
+        });
+      });
+    };
+    return {
+      ...(await next({
+        ...props,
+        getInitialData
+      })),
+      getInitialData
+    };
+  };
+}
+function getDataFromEl(el, key) {
+  if (el.text === undefined) {
+    console.error(`#${key} is completely empty. This could be due to CSP issues.`);
+  }
+  return el != null && el.text ? JSON.parse(el == null ? void 0 : el.text) : undefined;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJKU09OU3BvdXQiLCJpZCIsIm5leHQiLCJwcm9wcyIsImdldEluaXRpYWxEYXRhIiwia2V5IiwiZ2xvYmFsSWQiLCJQcm9taXNlIiwicmVzb2x2ZSIsInJlamVjdCIsImVsIiwiZG9jdW1lbnQiLCJnZXRFbGVtZW50QnlJZCIsImdldERhdGFGcm9tRWwiLCJhZGRFdmVudExpc3RlbmVyIiwiRXJyb3IiLCJ0ZXh0IiwidW5kZWZpbmVkIiwiY29uc29sZSIsImVycm9yIiwiSlNPTiIsInBhcnNlIl0sInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3Nwb3V0cy9qc29uLnRzeCJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IENsaWVudFNwb3V0IH0gZnJvbSAnLi90eXBlcy5qcyc7XG5cbmV4cG9ydCBkZWZhdWx0IGZ1bmN0aW9uIEpTT05TcG91dCh7XG4gIGlkID0gJ2FuYW5zaS1qc29uJyxcbn06IHsgaWQ/OiBzdHJpbmcgfSA9IHt9KTogQ2xpZW50U3BvdXQ8XG4gIFJlY29yZDxzdHJpbmcsIHVua25vd24+LFxuICB7IGdldEluaXRpYWxEYXRhOiAoa2V5OiBzdHJpbmcpID0+IFByb21pc2U8YW55PiB9XG4+IHtcbiAgcmV0dXJuIG5leHQgPT4gYXN5bmMgcHJvcHMgPT4ge1xuICAgIGNvbnN0IGdldEluaXRpYWxEYXRhID0gKGtleTogc3RyaW5nKSA9PiB7XG4gICAgICBjb25zdCBnbG9iYWxJZCA9IGAke2lkfS4ke2tleX1gO1xuICAgICAgcmV0dXJuIG5ldyBQcm9taXNlPGFueT4oKHJlc29sdmUsIHJlamVjdCkgPT4ge1xuICAgICAgICBsZXQgZWw6IEhUTUxTY3JpcHRFbGVtZW50IHwgbnVsbDtcbiAgICAgICAgaWYgKChlbCA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKGdsb2JhbElkKSBhcyBhbnkpKSB7XG4gICAgICAgICAgcmVzb2x2ZShnZXREYXRhRnJvbUVsKGVsLCBnbG9iYWxJZCkpO1xuICAgICAgICAgIHJldHVybjtcbiAgICAgICAgfVxuICAgICAgICBkb2N1bWVudC5hZGRFdmVudExpc3RlbmVyKCdET01Db250ZW50TG9hZGVkJywgKCkgPT4ge1xuICAgICAgICAgIGVsID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoZ2xvYmFsSWQpIGFzIGFueTtcbiAgICAgICAgICBpZiAoZWwpIHJlc29sdmUoZ2V0RGF0YUZyb21FbChlbCwgZ2xvYmFsSWQpKTtcbiAgICAgICAgICBlbHNlIHJlamVjdChuZXcgRXJyb3IoYGZhaWxlZCB0byBmaW5kIERPTSB3aXRoICR7a2V5fSBzdGF0ZWApKTtcbiAgICAgICAgfSk7XG4gICAgICB9KTtcbiAgICB9O1xuICAgIHJldHVybiB7IC4uLihhd2FpdCBuZXh0KHsgLi4ucHJvcHMsIGdldEluaXRpYWxEYXRhIH0pKSwgZ2V0SW5pdGlhbERhdGEgfTtcbiAgfTtcbn1cblxuZnVuY3Rpb24gZ2V0RGF0YUZyb21FbChlbDogSFRNTFNjcmlwdEVsZW1lbnQsIGtleTogc3RyaW5nKSB7XG4gIGlmIChlbC50ZXh0ID09PSB1bmRlZmluZWQpIHtcbiAgICBjb25zb2xlLmVycm9yKFxuICAgICAgYCMke2tleX0gaXMgY29tcGxldGVseSBlbXB0eS4gVGhpcyBjb3VsZCBiZSBkdWUgdG8gQ1NQIGlzc3Vlcy5gLFxuICAgICk7XG4gIH1cbiAgcmV0dXJuIGVsPy50ZXh0ID8gSlNPTi5wYXJzZShlbD8udGV4dCkgOiB1bmRlZmluZWQ7XG59XG4iXSwibWFwcGluZ3MiOiJBQUVBLGVBQWUsU0FBU0EsU0FBU0EsQ0FBQztFQUNoQ0MsRUFBRSxHQUFHO0FBQ1UsQ0FBQyxHQUFHLENBQUMsQ0FBQyxFQUdyQjtFQUNBLE9BQU9DLElBQUksSUFBSSxNQUFNQyxLQUFLLElBQUk7SUFDNUIsTUFBTUMsY0FBYyxHQUFJQyxHQUFXLElBQUs7TUFDdEMsTUFBTUMsUUFBUSxHQUFJLEdBQUVMLEVBQUcsSUFBR0ksR0FBSSxFQUFDO01BQy9CLE9BQU8sSUFBSUUsT0FBTyxDQUFNLENBQUNDLE9BQU8sRUFBRUMsTUFBTSxLQUFLO1FBQzNDLElBQUlDLEVBQTRCO1FBQ2hDLElBQUtBLEVBQUUsR0FBR0MsUUFBUSxDQUFDQyxjQUFjLENBQUNOLFFBQVEsQ0FBUSxFQUFHO1VBQ25ERSxPQUFPLENBQUNLLGFBQWEsQ0FBQ0gsRUFBRSxFQUFFSixRQUFRLENBQUMsQ0FBQztVQUNwQztRQUNGO1FBQ0FLLFFBQVEsQ0FBQ0csZ0JBQWdCLENBQUMsa0JBQWtCLEVBQUUsTUFBTTtVQUNsREosRUFBRSxHQUFHQyxRQUFRLENBQUNDLGNBQWMsQ0FBQ04sUUFBUSxDQUFRO1VBQzdDLElBQUlJLEVBQUUsRUFBRUYsT0FBTyxDQUFDSyxhQUFhLENBQUNILEVBQUUsRUFBRUosUUFBUSxDQUFDLENBQUMsQ0FBQyxLQUN4Q0csTUFBTSxDQUFDLElBQUlNLEtBQUssQ0FBRSwyQkFBMEJWLEdBQUksUUFBTyxDQUFDLENBQUM7UUFDaEUsQ0FBQyxDQUFDO01BQ0osQ0FBQyxDQUFDO0lBQ0osQ0FBQztJQUNELE9BQU87TUFBRSxJQUFJLE1BQU1ILElBQUksQ0FBQztRQUFFLEdBQUdDLEtBQUs7UUFBRUM7TUFBZSxDQUFDLENBQUMsQ0FBQztNQUFFQTtJQUFlLENBQUM7RUFDMUUsQ0FBQztBQUNIO0FBRUEsU0FBU1MsYUFBYUEsQ0FBQ0gsRUFBcUIsRUFBRUwsR0FBVyxFQUFFO0VBQ3pELElBQUlLLEVBQUUsQ0FBQ00sSUFBSSxLQUFLQyxTQUFTLEVBQUU7SUFDekJDLE9BQU8sQ0FBQ0MsS0FBSyxDQUNWLElBQUdkLEdBQUksd0RBQXVELENBQ2hFO0VBQ0g7RUFDQSxPQUFPSyxFQUFFLFlBQUZBLEVBQUUsQ0FBRU0sSUFBSSxHQUFHSSxJQUFJLENBQUNDLEtBQUssQ0FBQ1gsRUFBRSxvQkFBRkEsRUFBRSxDQUFFTSxJQUFJLENBQUMsR0FBR0MsU0FBUztBQUNwRCJ9

package/lib/scripts/spouts/json.server.js

@@ -0,0 +1,39 @@
+import _jsx from "@babel/runtime/helpers/jsx";
+import React, { Suspense } from 'react';
+export default function JSONSpout({
+  id = 'anansi-json'
+} = {}) {
+  return next => async props => {
+    var _nextProps$scripts, _nextProps$initData;
+    const nextProps = await next(props);
+    const scripts = (_nextProps$scripts = nextProps.scripts) != null ? _nextProps$scripts : [];
+    Object.entries((_nextProps$initData = nextProps.initData) != null ? _nextProps$initData : {}).forEach(([key, useData]) => {
+      const globalId = `${id}.${key}`;
+      const Script = () => {
+        const data = useData();
+        try {
+          const encoded = JSON.stringify(data);
+          return /*#__PURE__*/_jsx("script", {
+            id: globalId,
+            type: "application/json",
+            dangerouslySetInnerHTML: {
+              __html: encoded
+            },
+            nonce: props.nonce
+          });
+        } catch (e) {
+          // TODO: Use unified logging
+          console.error(`Error serializing json for ${key}`);
+          console.error(e);
+          return null;
+        }
+      };
+      scripts.push( /*#__PURE__*/_jsx(Suspense, {}, globalId, /*#__PURE__*/_jsx(Script, {})));
+    });
+    return {
+      ...nextProps,
+      scripts
+    };
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/scripts/spouts/prefetch.server.js

@@ -0,0 +1,20 @@
+export default function prefetchSpout(field) {
+  return function (next) {
+    return async props => {
+      const nextProps = await next(props);
+      try {
+        const toFetch = [];
+        nextProps.matchedRoutes.forEach(route => {
+          if (typeof route.resolveData === 'function') {
+            toFetch.push(route.resolveData(nextProps[field], route));
+          }
+        });
+        await Promise.all(toFetch);
+      } catch (e) {
+        console.error(e);
+      }
+      return nextProps;
+    };
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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