@depup/gatsby 5.16.1-depup.0

package/cache-dir/commonjs/static-query.js

@@ -0,0 +1,74 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.useStaticQuery = exports.StaticQueryContext = exports.StaticQuery = void 0;
+var _react = _interopRequireDefault(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _contextUtils = require("./context-utils");
+const StaticQueryContext = (0, _contextUtils.createServerOrClientContext)(`StaticQuery`, {});
+exports.StaticQueryContext = StaticQueryContext;
+function StaticQueryDataRenderer({
+  staticQueryData,
+  data,
+  query,
+  render
+}) {
+  const finalData = data ? data.data : staticQueryData[query] && staticQueryData[query].data;
+  return /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, finalData && render(finalData), !finalData && /*#__PURE__*/_react.default.createElement("div", null, "Loading (StaticQuery)"));
+}
+let warnedAboutStaticQuery = false;
+
+// TODO(v6): Remove completely
+const StaticQuery = props => {
+  const {
+    data,
+    query,
+    render,
+    children
+  } = props;
+  if (process.env.NODE_ENV === `development` && !warnedAboutStaticQuery) {
+    console.warn(`The <StaticQuery /> component is deprecated and will be removed in Gatsby v6. Use useStaticQuery instead. Refer to the migration guide for more information: https://gatsby.dev/migrating-4-to-5/#staticquery--is-deprecated`);
+    warnedAboutStaticQuery = true;
+  }
+  return /*#__PURE__*/_react.default.createElement(StaticQueryContext.Consumer, null, staticQueryData => /*#__PURE__*/_react.default.createElement(StaticQueryDataRenderer, {
+    data: data,
+    query: query,
+    render: render || children,
+    staticQueryData: staticQueryData
+  }));
+};
+exports.StaticQuery = StaticQuery;
+StaticQuery.propTypes = {
+  data: _propTypes.default.object,
+  query: _propTypes.default.string.isRequired,
+  render: _propTypes.default.func,
+  children: _propTypes.default.func
+};
+const useStaticQuery = query => {
+  var _context$query;
+  if (typeof _react.default.useContext !== `function` && process.env.NODE_ENV === `development`) {
+    // TODO(v5): Remove since we require React >= 18
+    throw new Error(`You're likely using a version of React that doesn't support Hooks\n` + `Please update React and ReactDOM to 16.8.0 or later to use the useStaticQuery hook.`);
+  }
+  const context = _react.default.useContext(StaticQueryContext);
+
+  // query is a stringified number like `3303882` when wrapped with graphql, If a user forgets
+  // to wrap the query in a grqphql, then casting it to a Number results in `NaN` allowing us to
+  // catch the misuse of the API and give proper direction
+  if (isNaN(Number(query))) {
+    throw new Error(`useStaticQuery was called with a string but expects to be called using \`graphql\`. Try this:
+
+import { useStaticQuery, graphql } from 'gatsby';
+
+useStaticQuery(graphql\`${query}\`);
+`);
+  }
+  if ((_context$query = context[query]) !== null && _context$query !== void 0 && _context$query.data) {
+    return context[query].data;
+  } else {
+    throw new Error(`The result of this StaticQuery could not be fetched.\n\n` + `This is likely a bug in Gatsby and if refreshing the page does not fix it, ` + `please open an issue in https://github.com/gatsbyjs/gatsby/issues`);
+  }
+};
+exports.useStaticQuery = useStaticQuery;
+//# sourceMappingURL=static-query.js.map

package/cache-dir/commonjs/static-query.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"static-query.js","names":["StaticQueryContext","createServerOrClientContext","StaticQueryDataRenderer","staticQueryData","data","query","render","finalData","warnedAboutStaticQuery","StaticQuery","props","children","process","env","NODE_ENV","console","warn","propTypes","PropTypes","object","string","isRequired","func","useStaticQuery","React","useContext","Error","context","isNaN","Number"],"sources":["../static-query.js"],"sourcesContent":["import React from \"react\"\nimport PropTypes from \"prop-types\"\nimport { createServerOrClientContext } from \"./context-utils\"\n\nconst StaticQueryContext = createServerOrClientContext(`StaticQuery`, {})\n\nfunction StaticQueryDataRenderer({ staticQueryData, data, query, render }) {\n  const finalData = data\n    ? data.data\n    : staticQueryData[query] && staticQueryData[query].data\n\n  return (\n    <React.Fragment>\n      {finalData && render(finalData)}\n      {!finalData && <div>Loading (StaticQuery)</div>}\n    </React.Fragment>\n  )\n}\n\nlet warnedAboutStaticQuery = false\n\n// TODO(v6): Remove completely\nconst StaticQuery = props => {\n  const { data, query, render, children } = props\n\n  if (process.env.NODE_ENV === `development` && !warnedAboutStaticQuery) {\n    console.warn(\n      `The <StaticQuery /> component is deprecated and will be removed in Gatsby v6. Use useStaticQuery instead. Refer to the migration guide for more information: https://gatsby.dev/migrating-4-to-5/#staticquery--is-deprecated`\n    )\n    warnedAboutStaticQuery = true\n  }\n\n  return (\n    <StaticQueryContext.Consumer>\n      {staticQueryData => (\n        <StaticQueryDataRenderer\n          data={data}\n          query={query}\n          render={render || children}\n          staticQueryData={staticQueryData}\n        />\n      )}\n    </StaticQueryContext.Consumer>\n  )\n}\n\nStaticQuery.propTypes = {\n  data: PropTypes.object,\n  query: PropTypes.string.isRequired,\n  render: PropTypes.func,\n  children: PropTypes.func,\n}\n\nconst useStaticQuery = query => {\n  if (\n    typeof React.useContext !== `function` &&\n    process.env.NODE_ENV === `development`\n  ) {\n    // TODO(v5): Remove since we require React >= 18\n    throw new Error(\n      `You're likely using a version of React that doesn't support Hooks\\n` +\n        `Please update React and ReactDOM to 16.8.0 or later to use the useStaticQuery hook.`\n    )\n  }\n\n  const context = React.useContext(StaticQueryContext)\n\n  // query is a stringified number like `3303882` when wrapped with graphql, If a user forgets\n  // to wrap the query in a grqphql, then casting it to a Number results in `NaN` allowing us to\n  // catch the misuse of the API and give proper direction\n  if (isNaN(Number(query))) {\n    throw new Error(`useStaticQuery was called with a string but expects to be called using \\`graphql\\`. Try this:\n\nimport { useStaticQuery, graphql } from 'gatsby';\n\nuseStaticQuery(graphql\\`${query}\\`);\n`)\n  }\n\n  if (context[query]?.data) {\n    return context[query].data\n  } else {\n    throw new Error(\n      `The result of this StaticQuery could not be fetched.\\n\\n` +\n        `This is likely a bug in Gatsby and if refreshing the page does not fix it, ` +\n        `please open an issue in https://github.com/gatsbyjs/gatsby/issues`\n    )\n  }\n}\n\nexport { StaticQuery, StaticQueryContext, useStaticQuery }\n"],"mappings":";;;;;AAAA;AACA;AACA;AAEA,MAAMA,kBAAkB,GAAG,IAAAC,yCAA2B,EAAE,aAAY,EAAE,CAAC,CAAC,CAAC;AAAA;AAEzE,SAASC,uBAAuB,CAAC;EAAEC,eAAe;EAAEC,IAAI;EAAEC,KAAK;EAAEC;AAAO,CAAC,EAAE;EACzE,MAAMC,SAAS,GAAGH,IAAI,GAClBA,IAAI,CAACA,IAAI,GACTD,eAAe,CAACE,KAAK,CAAC,IAAIF,eAAe,CAACE,KAAK,CAAC,CAACD,IAAI;EAEzD,oBACE,6BAAC,cAAK,CAAC,QAAQ,QACZG,SAAS,IAAID,MAAM,CAACC,SAAS,CAAC,EAC9B,CAACA,SAAS,iBAAI,0CAAK,uBAAqB,CAAM,CAChC;AAErB;AAEA,IAAIC,sBAAsB,GAAG,KAAK;;AAElC;AACA,MAAMC,WAAW,GAAGC,KAAK,IAAI;EAC3B,MAAM;IAAEN,IAAI;IAAEC,KAAK;IAAEC,MAAM;IAAEK;EAAS,CAAC,GAAGD,KAAK;EAE/C,IAAIE,OAAO,CAACC,GAAG,CAACC,QAAQ,KAAM,aAAY,IAAI,CAACN,sBAAsB,EAAE;IACrEO,OAAO,CAACC,IAAI,CACT,8NAA6N,CAC/N;IACDR,sBAAsB,GAAG,IAAI;EAC/B;EAEA,oBACE,6BAAC,kBAAkB,CAAC,QAAQ,QACzBL,eAAe,iBACd,6BAAC,uBAAuB;IACtB,IAAI,EAAEC,IAAK;IACX,KAAK,EAAEC,KAAM;IACb,MAAM,EAAEC,MAAM,IAAIK,QAAS;IAC3B,eAAe,EAAER;EAAgB,EAEpC,CAC2B;AAElC,CAAC;AAAA;AAEDM,WAAW,CAACQ,SAAS,GAAG;EACtBb,IAAI,EAAEc,kBAAS,CAACC,MAAM;EACtBd,KAAK,EAAEa,kBAAS,CAACE,MAAM,CAACC,UAAU;EAClCf,MAAM,EAAEY,kBAAS,CAACI,IAAI;EACtBX,QAAQ,EAAEO,kBAAS,CAACI;AACtB,CAAC;AAED,MAAMC,cAAc,GAAGlB,KAAK,IAAI;EAAA;EAC9B,IACE,OAAOmB,cAAK,CAACC,UAAU,KAAM,UAAS,IACtCb,OAAO,CAACC,GAAG,CAACC,QAAQ,KAAM,aAAY,EACtC;IACA;IACA,MAAM,IAAIY,KAAK,CACZ,qEAAoE,GAClE,qFAAoF,CACxF;EACH;EAEA,MAAMC,OAAO,GAAGH,cAAK,CAACC,UAAU,CAACzB,kBAAkB,CAAC;;EAEpD;EACA;EACA;EACA,IAAI4B,KAAK,CAACC,MAAM,CAACxB,KAAK,CAAC,CAAC,EAAE;IACxB,MAAM,IAAIqB,KAAK,CAAE;AACrB;AACA;AACA;AACA,0BAA0BrB,KAAM;AAChC,CAAC,CAAC;EACA;EAEA,sBAAIsB,OAAO,CAACtB,KAAK,CAAC,2CAAd,eAAgBD,IAAI,EAAE;IACxB,OAAOuB,OAAO,CAACtB,KAAK,CAAC,CAACD,IAAI;EAC5B,CAAC,MAAM;IACL,MAAM,IAAIsB,KAAK,CACZ,0DAAyD,GACvD,6EAA4E,GAC5E,mEAAkE,CACtE;EACH;AACF,CAAC;AAAA"}

package/cache-dir/commonjs/strip-prefix.js

@@ -0,0 +1,22 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = stripPrefix;
+/**
+ * Remove a prefix from a string. Return the input string if the given prefix
+ * isn't found.
+ */
+
+function stripPrefix(str, prefix = ``) {
+  if (!prefix) {
+    return str;
+  }
+  if (str === prefix) {
+    return `/`;
+  }
+  if (str.startsWith(`${prefix}/`)) {
+    return str.slice(prefix.length);
+  }
+  return str;
+}
+//# sourceMappingURL=strip-prefix.js.map

package/cache-dir/commonjs/strip-prefix.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"strip-prefix.js","names":["stripPrefix","str","prefix","startsWith","slice","length"],"sources":["../strip-prefix.js"],"sourcesContent":["/**\n * Remove a prefix from a string. Return the input string if the given prefix\n * isn't found.\n */\n\nexport default function stripPrefix(str, prefix = ``) {\n  if (!prefix) {\n    return str\n  }\n\n  if (str === prefix) {\n    return `/`\n  }\n\n  if (str.startsWith(`${prefix}/`)) {\n    return str.slice(prefix.length)\n  }\n\n  return str\n}\n"],"mappings":";;;;AAAA;AACA;AACA;AACA;;AAEe,SAASA,WAAW,CAACC,GAAG,EAAEC,MAAM,GAAI,EAAC,EAAE;EACpD,IAAI,CAACA,MAAM,EAAE;IACX,OAAOD,GAAG;EACZ;EAEA,IAAIA,GAAG,KAAKC,MAAM,EAAE;IAClB,OAAQ,GAAE;EACZ;EAEA,IAAID,GAAG,CAACE,UAAU,CAAE,GAAED,MAAO,GAAE,CAAC,EAAE;IAChC,OAAOD,GAAG,CAACG,KAAK,CAACF,MAAM,CAACG,MAAM,CAAC;EACjC;EAEA,OAAOJ,GAAG;AACZ"}

package/cache-dir/context-utils.js

@@ -0,0 +1,29 @@
+import React from "react"
+
+// Ensure serverContext is not created more than once as React will throw when creating it more than once
+// https://github.com/facebook/react/blob/dd2d6522754f52c70d02c51db25eb7cbd5d1c8eb/packages/react/src/ReactServerContext.js#L101
+const createServerContext = (name, defaultValue = null) => {
+  /* eslint-disable no-undef */
+  if (!globalThis.__SERVER_CONTEXT) {
+    globalThis.__SERVER_CONTEXT = {}
+  }
+
+  if (!globalThis.__SERVER_CONTEXT[name]) {
+    globalThis.__SERVER_CONTEXT[name] = React.createServerContext(
+      name,
+      defaultValue
+    )
+  }
+
+  return globalThis.__SERVER_CONTEXT[name]
+}
+
+function createServerOrClientContext(name, defaultValue) {
+  if (React.createServerContext) {
+    return createServerContext(name, defaultValue)
+  }
+
+  return React.createContext(defaultValue)
+}
+
+export { createServerOrClientContext }

package/cache-dir/create-content-digest-browser-shim.js

@@ -0,0 +1 @@
+exports.createContentDigest = () => ``

package/cache-dir/css-to-object.js

@@ -0,0 +1,19 @@
+/**
+ * Converts a string of CSS into object syntax
+ * @param strings
+ * @param keys
+ * @returns {Object} CSS in object syntax
+ * @example
+ * const output = css`
+ *  html {
+ *    color: rebeccapurple;
+ *  }
+ * `
+ */
+export function css(strings, ...keys) {
+  const lastIndex = strings.length - 1
+  return (
+    strings.slice(0, lastIndex).reduce((p, s, i) => p + s + keys[i], ``) +
+    strings[lastIndex]
+  )
+}

package/cache-dir/debug-log.js

@@ -0,0 +1,13 @@
+// inspired by https://github.com/GoogleChrome/workbox/blob/3d02230f0e977eb1dc86c48f16ea4bcefdae12af/packages/workbox-core/src/_private/logger.ts
+
+const styles = [
+  `background: rebeccapurple`,
+  `border-radius: 0.5em`,
+  `color: white`,
+  `font-weight: bold`,
+  `padding: 2px 0.5em`,
+].join(`;`)
+
+export function debugLog(...args) {
+  console.debug(`%cgatsby`, styles, ...args)
+}

package/cache-dir/default-html.js

@@ -0,0 +1,36 @@
+import React from "react"
+import PropTypes from "prop-types"
+
+export default function HTML(props) {
+  return (
+    <html {...props.htmlAttributes}>
+      <head>
+        <meta charSet="utf-8" />
+        <meta httpEquiv="x-ua-compatible" content="ie=edge" />
+        <meta
+          name="viewport"
+          content="width=device-width, initial-scale=1, shrink-to-fit=no"
+        />
+        {props.headComponents}
+      </head>
+      <body {...props.bodyAttributes}>
+        {props.preBodyComponents}
+        <div
+          key={`body`}
+          id="___gatsby"
+          dangerouslySetInnerHTML={{ __html: props.body }}
+        />
+        {props.postBodyComponents}
+      </body>
+    </html>
+  )
+}
+
+HTML.propTypes = {
+  htmlAttributes: PropTypes.object,
+  headComponents: PropTypes.array,
+  bodyAttributes: PropTypes.object,
+  preBodyComponents: PropTypes.array,
+  body: PropTypes.string,
+  postBodyComponents: PropTypes.array,
+}

package/cache-dir/dev-loader.js

@@ -0,0 +1,280 @@
+import { BaseLoader, PageResourceStatus } from "./loader"
+import { findPath } from "./find-path"
+
+import getSocket from "./socketIo"
+import normalizePagePath from "./normalize-page-path"
+
+// TODO move away from lodash
+import isEqual from "lodash/isEqual"
+
+function mergePageEntry(cachedPage, newPageData) {
+  return {
+    ...cachedPage,
+    payload: {
+      ...cachedPage.payload,
+      json: {
+        // For SSR, cachedPage may contain "data" and "serverData"
+        // But newPageData may contain only "data" or only "serverData" depending on what was updated
+        ...cachedPage.payload.json,
+        ...newPageData.result,
+      },
+      page: {
+        ...cachedPage.payload.page,
+        getServerDataError: newPageData.getServerDataError,
+        staticQueryResults: newPageData.staticQueryResults,
+      },
+    },
+  }
+}
+
+class DevLoader extends BaseLoader {
+  constructor(asyncRequires, matchPaths) {
+    const loadComponent = (chunkName, exportType = `components`) => {
+      if (!this.asyncRequires[exportType][chunkName]) {
+        if (exportType === `head`) {
+          return null
+        }
+        throw new Error(
+          `We couldn't find the correct component chunk with the name "${chunkName}"`
+        )
+      }
+
+      return (
+        this.asyncRequires[exportType][chunkName]()
+          // loader will handle the case when component is error
+          .catch(err => err)
+      )
+    }
+    super(loadComponent, matchPaths)
+    this.asyncRequires = asyncRequires
+
+    const socket = getSocket()
+
+    this.notFoundPagePathsInCaches = new Set()
+
+    if (socket) {
+      socket.on(`message`, msg => {
+        if (msg.type === `staticQueryResult`) {
+          this.handleStaticQueryResultHotUpdate(msg)
+        } else if (msg.type === `pageQueryResult`) {
+          this.handlePageQueryResultHotUpdate(msg)
+        } else if (msg.type === `sliceQueryResult`) {
+          this.handleSliceQueryResultHotUpdate(msg)
+        } else if (msg.type === `stalePageData`) {
+          this.handleStalePageDataMessage(msg)
+        } else if (msg.type === `staleServerData`) {
+          this.handleStaleServerDataMessage(msg)
+        }
+      })
+    } else if (process.env.NODE_ENV !== `test`) {
+      console.warn(`Could not get web socket`)
+    }
+  }
+
+  updateAsyncRequires(asyncRequires) {
+    this.asyncRequires = asyncRequires
+  }
+
+  loadPage(pagePath) {
+    const realPath = findPath(pagePath)
+    return super.loadPage(realPath).then(result => {
+      if (this.isPageNotFound(realPath)) {
+        this.notFoundPagePathsInCaches.add(realPath)
+      }
+
+      return result
+    })
+  }
+
+  loadPageDataJson(rawPath) {
+    return super.loadPageDataJson(rawPath).then(data => {
+      // when we can't find a proper 404.html we fallback to dev-404-page
+      // we need to make sure to mark it as not found.
+      if (
+        data.status === PageResourceStatus.Error &&
+        rawPath !== `/dev-404-page/`
+      ) {
+        console.error(
+          `404 page could not be found. Checkout https://www.gatsbyjs.com/docs/how-to/adding-common-features/add-404-page/`
+        )
+        return this.loadPageDataJson(`/dev-404-page/`).then(result =>
+          Object.assign({}, data, result)
+        )
+      }
+
+      return data
+    })
+  }
+
+  doPrefetch(pagePath) {
+    if (process.env.GATSBY_QUERY_ON_DEMAND) {
+      return Promise.resolve()
+    }
+    return super.doPrefetch(pagePath).then(result => result.payload)
+  }
+
+  handleStaticQueryResultHotUpdate(msg) {
+    const newResult = msg.payload.result
+
+    const cacheKey = msg.payload.id
+    const cachedResult = this.staticQueryDb[cacheKey]
+    if (!isEqual(newResult, cachedResult)) {
+      this.staticQueryDb[cacheKey] = newResult
+      ___emitter.emit(`staticQueryResult`, newResult)
+    }
+  }
+
+  handleSliceQueryResultHotUpdate(msg) {
+    const newResult = msg.payload.result
+
+    const cacheKey = msg.payload.id
+
+    // raw json db
+    {
+      const cachedResult = this.slicesDataDb.get(cacheKey)
+      if (!isEqual(newResult, cachedResult)) {
+        this.slicesDataDb.set(cacheKey, newResult)
+      }
+    }
+
+    // processed data
+    {
+      const cachedResult = this.slicesDb.get(cacheKey)
+      if (
+        !isEqual(newResult?.result?.data, cachedResult?.data) ||
+        !isEqual(newResult?.result?.sliceContext, cachedResult?.sliceContext)
+      ) {
+        const mergedResult = {
+          ...cachedResult,
+          data: newResult?.result?.data,
+          sliceContext: newResult?.result?.sliceContext,
+        }
+        this.slicesDb.set(cacheKey, mergedResult)
+        ___emitter.emit(`sliceQueryResult`, mergedResult)
+      }
+    }
+  }
+
+  updatePageData = (pagePath, newPageData) => {
+    const pageDataDbCacheKey = normalizePagePath(pagePath)
+    const cachedPageData = this.pageDataDb.get(pageDataDbCacheKey)?.payload
+
+    if (!isEqual(newPageData, cachedPageData)) {
+      // TODO: if this is update for current page and there are any new static queries added
+      // that are not yet cached, there is currently no trigger to fetch them (yikes)
+      // always update canonical key for pageDataDb
+      this.pageDataDb.set(pageDataDbCacheKey, {
+        pagePath: pageDataDbCacheKey,
+        payload: newPageData,
+        status: `success`,
+      })
+
+      const cachedPage = this.pageDb.get(pageDataDbCacheKey)
+      if (cachedPage) {
+        this.pageDb.set(
+          pageDataDbCacheKey,
+          mergePageEntry(cachedPage, newPageData)
+        )
+      }
+
+      // Additionally if those are query results for "/404.html"
+      // we have to update all paths user wanted to visit, but didn't have
+      // page for it, because we do store them under (normalized) path
+      // user wanted to visit
+      if (pageDataDbCacheKey === `/404.html`) {
+        this.notFoundPagePathsInCaches.forEach(notFoundPath => {
+          const previousPageDataEntry = this.pageDataDb.get(notFoundPath)
+          if (previousPageDataEntry) {
+            this.pageDataDb.set(notFoundPath, {
+              ...previousPageDataEntry,
+              payload: newPageData,
+            })
+          }
+
+          const previousPageEntry = this.pageDb.get(notFoundPath)
+          if (previousPageEntry) {
+            this.pageDb.set(
+              notFoundPath,
+              mergePageEntry(previousPageEntry, newPageData)
+            )
+          }
+        })
+      }
+      return true
+    }
+    return false
+  }
+
+  markAsStale = dirtyQueryId => {
+    if (dirtyQueryId === `/dev-404-page/` || dirtyQueryId === `/404.html`) {
+      // those pages are not on demand so skipping
+      return
+    }
+
+    const normalizedId = normalizePagePath(dirtyQueryId)
+
+    // We can't just delete items in caches, because then
+    // using history.back() would show dev-404 page
+    // due to our special handling of it in root.js (loader.isPageNotFound check)
+    // so instead we mark it as stale and instruct loader's async methods
+    // to refetch resources if they are marked as stale
+
+    const cachedPageData = this.pageDataDb.get(normalizedId)
+    if (cachedPageData) {
+      // if we have page data in cache, mark it as stale
+      this.pageDataDb.set(normalizedId, {
+        ...cachedPageData,
+        stale: true,
+      })
+    }
+
+    const cachedPage = this.pageDb.get(normalizedId)
+    if (cachedPage) {
+      // if we have page data in cache, mark it as stale
+      this.pageDb.set(normalizedId, {
+        ...cachedPage,
+        payload: { ...cachedPage.payload, stale: true },
+      })
+    }
+  }
+
+  handlePageQueryResultHotUpdate(msg) {
+    const updated = this.updatePageData(msg.payload.id, msg.payload.result)
+    if (updated) {
+      ___emitter.emit(`pageQueryResult`, msg.payload.result)
+    }
+  }
+
+  handleStalePageDataMessage(msg) {
+    for (const dirtyQueryId of msg.payload.stalePageDataPaths) {
+      this.markAsStale(dirtyQueryId)
+    }
+  }
+
+  handleStaleServerDataMessage() {
+    const activePath = normalizePagePath(location.pathname)
+
+    // For now just invalidate every single page with serverData
+    for (const [key, value] of this.pageDataDb) {
+      if (value?.payload?.result?.serverData) {
+        this.markAsStale(key)
+      }
+      if (activePath === normalizePagePath(key)) {
+        this.reFetchServerData(activePath)
+      }
+    }
+  }
+
+  reFetchServerData(pagePath) {
+    this.fetchPageDataJson({ pagePath }).then(data => {
+      const updated = this.updatePageData(data.pagePath, data.payload)
+      // SSR could be slow, so we should only emit serverDataResult
+      // when still on the same page
+      if (updated && pagePath === normalizePagePath(location.pathname)) {
+        ___emitter.emit(`serverDataResult`, data.payload)
+      }
+    })
+  }
+}
+
+export default DevLoader

package/cache-dir/develop-static-entry.js

@@ -0,0 +1,129 @@
+/* global BROWSER_ESM_ONLY */
+import React from "react"
+import { renderToStaticMarkup } from "react-dom/server"
+import { merge } from "lodash"
+import { apiRunner } from "./api-runner-ssr"
+import asyncRequires from "$virtual/async-requires"
+
+const testRequireError = (moduleName, err) => {
+  const regex = new RegExp(`Error: Cannot find module\\s.${moduleName}`)
+  const firstLine = err.toString().split(`\n`)[0]
+  return regex.test(firstLine)
+}
+
+let Html
+try {
+  Html = require(`../src/html`)
+} catch (err) {
+  if (testRequireError(`../src/html`, err)) {
+    Html = require(`./default-html`)
+  } else {
+    console.log(`There was an error requiring "src/html.js"\n\n`, err, `\n\n`)
+    process.exit()
+  }
+}
+
+Html = Html && Html.__esModule ? Html.default : Html
+
+export default ({ pagePath }) => {
+  let headComponents = [
+    <meta key="environment" name="note" content="environment=development" />,
+  ]
+  let htmlAttributes = {}
+  let bodyAttributes = {}
+  let preBodyComponents = []
+  let postBodyComponents = []
+  let bodyProps = {}
+  let htmlStr
+
+  const setHeadComponents = components => {
+    headComponents = headComponents.concat(components)
+  }
+
+  const setHtmlAttributes = attributes => {
+    htmlAttributes = merge(htmlAttributes, attributes)
+  }
+
+  const setBodyAttributes = attributes => {
+    bodyAttributes = merge(bodyAttributes, attributes)
+  }
+
+  const setPreBodyComponents = components => {
+    preBodyComponents = preBodyComponents.concat(components)
+  }
+
+  const setPostBodyComponents = components => {
+    postBodyComponents = postBodyComponents.concat(components)
+  }
+
+  const setBodyProps = props => {
+    bodyProps = merge({}, bodyProps, props)
+  }
+
+  const getHeadComponents = () => headComponents
+
+  const replaceHeadComponents = components => {
+    headComponents = components
+  }
+
+  const getPreBodyComponents = () => preBodyComponents
+
+  const replacePreBodyComponents = components => {
+    preBodyComponents = components
+  }
+
+  const getPostBodyComponents = () => postBodyComponents
+
+  const replacePostBodyComponents = components => {
+    postBodyComponents = components
+  }
+
+  apiRunner(`onRenderBody`, {
+    setHeadComponents,
+    setHtmlAttributes,
+    setBodyAttributes,
+    setPreBodyComponents,
+    setPostBodyComponents,
+    setBodyProps,
+    pathname: pagePath,
+  })
+
+  apiRunner(`onPreRenderHTML`, {
+    getHeadComponents,
+    replaceHeadComponents,
+    getPreBodyComponents,
+    replacePreBodyComponents,
+    getPostBodyComponents,
+    replacePostBodyComponents,
+    pathname: pagePath,
+  })
+
+  const htmlElement = React.createElement(Html, {
+    ...bodyProps,
+    body: ``,
+    headComponents: headComponents.concat([
+      <script key={`io`} src="/socket.io/socket.io.js" />,
+      <link key="styles" rel="stylesheet" href="/commons.css" />,
+    ]),
+    htmlAttributes,
+    bodyAttributes,
+    preBodyComponents,
+    postBodyComponents: postBodyComponents.concat(
+      [
+        !BROWSER_ESM_ONLY && (
+          <script key={`polyfill`} src="/polyfill.js" noModule={true} />
+        ),
+        <script key={`framework`} src="/framework.js" />,
+        <script key={`commons`} src="/commons.js" />,
+      ].filter(Boolean)
+    ),
+  })
+  htmlStr = renderToStaticMarkup(htmlElement)
+  htmlStr = `<!DOCTYPE html>${htmlStr}`
+
+  return htmlStr
+}
+
+export function getPageChunk({ componentChunkName }) {
+  return asyncRequires.components[componentChunkName]()
+}

package/cache-dir/dummy.js

@@ -0,0 +1,2 @@
+// Dummy file to work around a webpack hot reloading bug.
+export const a = 1

package/cache-dir/emitter.js

@@ -0,0 +1,4 @@
+import mitt from "mitt"
+
+const emitter = mitt()
+export default emitter