gatsby 4.18.0-next.2 → 4.18.2

package/cache-dir/app.js

@@ -40,23 +40,36 @@ loader.setApiRunner(apiRunner)
 
 window.___loader = publicLoader
 
-let reactRender
-let reactHydrate
+let reactFirstRenderOrHydrate
 if (HAS_REACT_18) {
   const reactDomClient = require(`react-dom/client`)
-  reactRender = (Component, el) => {
-    const root = reactDomClient.createRoot(el)
-    root.render(Component)
-    return () => root.unmount()
+  reactFirstRenderOrHydrate = (Component, el) => {
+    // we will use hydrate if mount element has any content inside
+    const useHydrate = el && el.children.length
+
+    if (useHydrate) {
+      const root = reactDomClient.hydrateRoot(el, Component)
+      return () => root.unmount()
+    } else {
+      const root = reactDomClient.createRoot(el)
+      root.render(Component)
+      return () => root.unmount()
+    }
   }
-  reactHydrate = (Component, el) => reactDomClient.hydrateRoot(el, Component)
 } else {
   const reactDomClient = require(`react-dom`)
-  reactRender = (Component, el) => {
-    reactDomClient.render(Component, el)
-    return () => ReactDOM.unmountComponentAtNode(el)
+  reactFirstRenderOrHydrate = (Component, el) => {
+    // we will use hydrate if mount element has any content inside
+    const useHydrate = el && el.children.length
+
+    if (useHydrate) {
+      reactDomClient.hydrate(Component, el)
+      return () => ReactDOM.unmountComponentAtNode(el)
+    } else {
+      reactDomClient.render(Component, el)
+      return () => ReactDOM.unmountComponentAtNode(el)
+    }
   }
-  reactHydrate = reactDomClient.hydrate
 }
 
 // Do dummy dynamic import so the jsonp __webpack_require__.e is added to the commons.js
@@ -147,20 +160,10 @@ apiRunnerAsync(`onClientEntry`).then(() => {
   }
 
   const rootElement = document.getElementById(`___gatsby`)
-
-  const focusEl = document.getElementById(`gatsby-focus-wrapper`)
-
-  // Client only pages have any empty body so we just do a normal
-  // render to avoid React complaining about hydration mis-matches.
-  let defaultRenderer = reactRender
-  if (focusEl && focusEl.children.length) {
-    defaultRenderer = reactHydrate
-  }
-
   const renderer = apiRunner(
     `replaceHydrateFunction`,
     undefined,
-    defaultRenderer
+    reactFirstRenderOrHydrate
   )[0]
 
   let dismissLoadingIndicator
@@ -184,7 +187,7 @@ apiRunnerAsync(`onClientEntry`).then(() => {
       if (indicatorMountElement) {
         // If user defined replaceHydrateFunction themselves the cleanupFn return might not be there
         // So fallback to unmountComponentAtNode for now
-        if (cleanupFn) {
+        if (cleanupFn && typeof cleanupFn === `function`) {
           cleanupFn()
         } else {
           ReactDOM.unmountComponentAtNode(indicatorMountElement)

package/cache-dir/commonjs/app.js

@@ -52,28 +52,39 @@ const loader = new _devLoader.default(_asyncRequires.default, _matchPaths.defaul
 (0, _loader.setLoader)(loader);
 loader.setApiRunner(_apiRunnerBrowser.apiRunner);
 window.___loader = _loader.publicLoader;
-let reactRender;
-let reactHydrate;
+let reactFirstRenderOrHydrate;
 
 if (HAS_REACT_18) {
   const reactDomClient = require(`react-dom/client`);
 
-  reactRender = (Component, el) => {
-    const root = reactDomClient.createRoot(el);
-    root.render(Component);
-    return () => root.unmount();
-  };
+  reactFirstRenderOrHydrate = (Component, el) => {
+    // we will use hydrate if mount element has any content inside
+    const useHydrate = el && el.children.length;
 
-  reactHydrate = (Component, el) => reactDomClient.hydrateRoot(el, Component);
+    if (useHydrate) {
+      const root = reactDomClient.hydrateRoot(el, Component);
+      return () => root.unmount();
+    } else {
+      const root = reactDomClient.createRoot(el);
+      root.render(Component);
+      return () => root.unmount();
+    }
+  };
 } else {
   const reactDomClient = require(`react-dom`);
 
-  reactRender = (Component, el) => {
-    reactDomClient.render(Component, el);
-    return () => _reactDom.default.unmountComponentAtNode(el);
-  };
+  reactFirstRenderOrHydrate = (Component, el) => {
+    // we will use hydrate if mount element has any content inside
+    const useHydrate = el && el.children.length;
 
-  reactHydrate = reactDomClient.hydrate;
+    if (useHydrate) {
+      reactDomClient.hydrate(Component, el);
+      return () => _reactDom.default.unmountComponentAtNode(el);
+    } else {
+      reactDomClient.render(Component, el);
+      return () => _reactDom.default.unmountComponentAtNode(el);
+    }
+  };
 } // Do dummy dynamic import so the jsonp __webpack_require__.e is added to the commons.js
 // bundle. This ensures hot reloading doesn't break when someone first adds
 // a dynamic import.
@@ -139,16 +150,7 @@ function notCalledFunction() {
   }
 
   const rootElement = document.getElementById(`___gatsby`);
-  const focusEl = document.getElementById(`gatsby-focus-wrapper`); // Client only pages have any empty body so we just do a normal
-  // render to avoid React complaining about hydration mis-matches.
-
-  let defaultRenderer = reactRender;
-
-  if (focusEl && focusEl.children.length) {
-    defaultRenderer = reactHydrate;
-  }
-
-  const renderer = (0, _apiRunnerBrowser.apiRunner)(`replaceHydrateFunction`, undefined, defaultRenderer)[0];
+  const renderer = (0, _apiRunnerBrowser.apiRunner)(`replaceHydrateFunction`, undefined, reactFirstRenderOrHydrate)[0];
   let dismissLoadingIndicator;
 
   if (process.env.GATSBY_EXPERIMENTAL_QUERY_ON_DEMAND && process.env.GATSBY_QUERY_ON_DEMAND_LOADING_INDICATOR === `true`) {
@@ -166,7 +168,7 @@ function notCalledFunction() {
       if (indicatorMountElement) {
         // If user defined replaceHydrateFunction themselves the cleanupFn return might not be there
         // So fallback to unmountComponentAtNode for now
-        if (cleanupFn) {
+        if (cleanupFn && typeof cleanupFn === `function`) {
           cleanupFn();
         } else {
           _reactDom.default.unmountComponentAtNode(indicatorMountElement);

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

@@ -239,15 +239,8 @@ async function staticPage({
             ...(((_pageData$result = pageData.result) === null || _pageData$result === void 0 ? void 0 : (_pageData$result$page = _pageData$result.pageContext) === null || _pageData$result$page === void 0 ? void 0 : _pageData$result$page.__params) || {})
           }
         };
-        let pageElement;
-
-        if (_ssrSyncRequires.default.ssrComponents[componentChunkName] && !isClientOnlyPage) {
-          pageElement = /*#__PURE__*/_react.default.createElement(preferDefault(_ssrSyncRequires.default.ssrComponents[componentChunkName]), props);
-        } else {
-          // If this is a client-only page or the pageComponent didn't finish
-          // compiling yet, just render an empty component.
-          pageElement = () => null;
-        }
+
+        const pageElement = /*#__PURE__*/_react.default.createElement(preferDefault(_ssrSyncRequires.default.ssrComponents[componentChunkName]), props);
 
         const wrappedPage = (0, _apiRunnerSsr.apiRunner)(`wrapPageElement`, {
           element: pageElement,
@@ -265,15 +258,14 @@ async function staticPage({
 
     }
 
-    const routerElement = /*#__PURE__*/_react.default.createElement(_router.ServerLocation, {
+    const routerElement = _ssrSyncRequires.default.ssrComponents[componentChunkName] && !isClientOnlyPage ? /*#__PURE__*/_react.default.createElement(_router.ServerLocation, {
       url: `${__BASE_PATH__}${pagePath}`
     }, /*#__PURE__*/_react.default.createElement(_router.Router, {
       id: "gatsby-focus-wrapper",
       baseuri: __BASE_PATH__
     }, /*#__PURE__*/_react.default.createElement(RouteHandler, {
       path: "/*"
-    })), /*#__PURE__*/_react.default.createElement("div", _routeAnnouncerProps.RouteAnnouncerProps));
-
+    })), /*#__PURE__*/_react.default.createElement("div", _routeAnnouncerProps.RouteAnnouncerProps)) : null;
     const bodyComponent = (0, _apiRunnerSsr.apiRunner)(`wrapRootElement`, {
       element: routerElement,
       pathname: pagePath

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

@@ -324,7 +324,9 @@ async function staticPage({
               pipe(writableStream);
             },
 
-            onError() {}
+            onError(error) {
+              throw error;
+            }
 
           });
           bodyHtml = await writableStream;

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

@@ -235,20 +235,10 @@ export default async function staticPage({
           },
         }
 
-        let pageElement
-        if (
-          syncRequires.ssrComponents[componentChunkName] &&
-          !isClientOnlyPage
-        ) {
-          pageElement = React.createElement(
-            preferDefault(syncRequires.ssrComponents[componentChunkName]),
-            props
-          )
-        } else {
-          // If this is a client-only page or the pageComponent didn't finish
-          // compiling yet, just render an empty component.
-          pageElement = () => null
-        }
+        const pageElement = React.createElement(
+          preferDefault(syncRequires.ssrComponents[componentChunkName]),
+          props
+        )
 
         const wrappedPage = apiRunner(
           `wrapPageElement`,
@@ -263,14 +253,15 @@ export default async function staticPage({
       }
     }
 
-    const routerElement = (
-      <ServerLocation url={`${__BASE_PATH__}${pagePath}`}>
-        <Router id="gatsby-focus-wrapper" baseuri={__BASE_PATH__}>
-          <RouteHandler path="/*" />
-        </Router>
-        <div {...RouteAnnouncerProps} />
-      </ServerLocation>
-    )
+    const routerElement =
+      syncRequires.ssrComponents[componentChunkName] && !isClientOnlyPage ? (
+        <ServerLocation url={`${__BASE_PATH__}${pagePath}`}>
+          <Router id="gatsby-focus-wrapper" baseuri={__BASE_PATH__}>
+            <RouteHandler path="/*" />
+          </Router>
+          <div {...RouteAnnouncerProps} />
+        </ServerLocation>
+      ) : null
 
     const bodyComponent = apiRunner(
       `wrapRootElement`,

package/cache-dir/static-entry.js

@@ -287,7 +287,9 @@ export default async function staticPage({
             onAllReady() {
               pipe(writableStream)
             },
-            onError() {},
+            onError(error) {
+              throw error
+            },
           })
 
           bodyHtml = await writableStream

package/dist/datastore/in-memory/indexing.d.ts

@@ -6,6 +6,7 @@ declare type GatsbyNodeID = string;
 export interface IGatsbyNodePartial {
     id: GatsbyNodeID;
     internal: {
+        type: string;
         counter: number;
     };
     gatsbyNodePartialInternalData: {

package/dist/datastore/in-memory/indexing.js

@@ -12,14 +12,14 @@ exports.unionNodesByCounter = unionNodesByCounter;
 
 var _every2 = _interopRequireDefault(require("lodash/every"));
 
-var _redux = require("../../redux");
-
 var _query = require("../common/query");
 
 var _2 = require("../");
 
 var _getValueAt = require("../../utils/get-value-at");
 
+var _utils = require("../../schema/utils");
+
 const nodeIdToIdentifierMap = new Map();
 /**
  * Grabs an instance of IGatsbyNodePartial for the given node.
@@ -49,30 +49,27 @@ const getGatsbyNodePartial = (node, indexFields, resolvedFields) => {
   const fieldsToStore = derefPartial ? new Set([...derefPartial.gatsbyNodePartialInternalData.indexFields, ...indexFields]) : new Set(indexFields);
   const sortFieldIds = getSortFieldIdentifierKeys([...fieldsToStore], resolvedFields);
   let fullNodeObject = node.gatsbyNodePartialInternalData ? undefined : node;
+  let resolvedNodeFields;
 
   for (const dottedField of sortFieldIds) {
     if (dottedField in node) {
       dottedFields[dottedField] = node[dottedField];
     } else {
-      // if we haven't gotten the full node object, fetch it once
-      if (!fullNodeObject) {
-        fullNodeObject = (0, _2.getNode)(node.id);
-      }
-
-      if (dottedField.startsWith(`__gatsby_resolved.`) && !fullNodeObject.__gatsby_resolved) {
-        const typeName = fullNodeObject.internal.type;
-
-        const resolvedNodes = _redux.store.getState().resolvedNodesCache.get(typeName);
-
-        const resolved = resolvedNodes === null || resolvedNodes === void 0 ? void 0 : resolvedNodes.get(fullNodeObject.id);
-
-        if (resolved !== undefined) {
-          fullNodeObject.__gatsby_resolved = resolved;
+      if (dottedField.startsWith(`__gatsby_resolved.`)) {
+        if (!resolvedNodeFields) {
+          resolvedNodeFields = (0, _utils.getResolvedFields)(node);
         }
-      } // use the full node object to fetch the value
 
+        dottedFields[dottedField] = (0, _getValueAt.getValueAt)(resolvedNodeFields, dottedField.slice(`__gatsby_resolved.`.length));
+      } else {
+        // if we haven't gotten the full node object, fetch it once
+        // use the full node object to fetch the value
+        if (!fullNodeObject) {
+          fullNodeObject = (0, _2.getNode)(node.id);
+        }
 
-      dottedFields[dottedField] = (0, _getValueAt.getValueAt)(fullNodeObject, dottedField);
+        dottedFields[dottedField] = (0, _getValueAt.getValueAt)(fullNodeObject, dottedField);
+      }
     }
   } // create the partial object
 
@@ -80,7 +77,8 @@ const getGatsbyNodePartial = (node, indexFields, resolvedFields) => {
   const partial = Object.assign(dottedFields, {
     id: node.id,
     internal: {
-      counter: node.internal.counter
+      counter: node.internal.counter,
+      type: node.internal.type
     },
     gatsbyNodePartialInternalData: {
       indexFields: fieldsToStore
@@ -200,9 +198,6 @@ function postIndexingMetaSetupLtLteGtGte(filterCache, op) {
 
 
 const ensureIndexByQuery = (op, filterCacheKey, filterPath, nodeTypeNames, filtersCache, indexFields, resolvedFields) => {
-  const state = _redux.store.getState();
-
-  const resolvedNodesCache = state.resolvedNodesCache;
   const filterCache = {
     op,
     byValue: new Map(),
@@ -218,7 +213,6 @@ const ensureIndexByQuery = (op, filterCacheKey, filterPath, nodeTypeNames, filte
         node,
         chain: filterPath,
         filterCache,
-        resolvedNodesCache,
         indexFields,
         resolvedFields
       });
@@ -235,7 +229,6 @@ const ensureIndexByQuery = (op, filterCacheKey, filterPath, nodeTypeNames, filte
         node,
         chain: filterPath,
         filterCache,
-        resolvedNodesCache,
         indexFields,
         resolvedFields
       });
@@ -251,9 +244,6 @@ function ensureEmptyFilterCache(filterCacheKey, nodeTypeNames, filtersCache, ind
   // This is called for queries without any filters
   // We want to cache the result since it's basically a list of nodes by type(s)
   // There are sites that have multiple queries which are empty
-  const state = _redux.store.getState();
-
-  const resolvedNodesCache = state.resolvedNodesCache;
   const orderedByCounter = [];
   filtersCache.set(filterCacheKey, {
     op: `$eq`,
@@ -267,16 +257,6 @@ function ensureEmptyFilterCache(filterCacheKey, nodeTypeNames, filtersCache, ind
 
   if (nodeTypeNames.length === 1) {
     (0, _2.getDataStore)().iterateNodesByType(nodeTypeNames[0]).forEach(node => {
-      if (!node.__gatsby_resolved) {
-        const typeName = node.internal.type;
-        const resolvedNodes = resolvedNodesCache.get(typeName);
-        const resolved = resolvedNodes === null || resolvedNodes === void 0 ? void 0 : resolvedNodes.get(node.id);
-
-        if (resolved !== undefined) {
-          node.__gatsby_resolved = resolved;
-        }
-      }
-
       orderedByCounter.push(getGatsbyNodePartial(node, indexFields, resolvedFields));
     });
   } else {
@@ -284,16 +264,6 @@ function ensureEmptyFilterCache(filterCacheKey, nodeTypeNames, filtersCache, ind
     // This loop is expensive at scale (!)
     (0, _2.getDataStore)().iterateNodes().forEach(node => {
       if (nodeTypeNames.includes(node.internal.type)) {
-        if (!node.__gatsby_resolved) {
-          const typeName = node.internal.type;
-          const resolvedNodes = resolvedNodesCache.get(typeName);
-          const resolved = resolvedNodes === null || resolvedNodes === void 0 ? void 0 : resolvedNodes.get(node.id);
-
-          if (resolved !== undefined) {
-            node.__gatsby_resolved = resolved;
-          }
-        }
-
         orderedByCounter.push(getGatsbyNodePartial(node, indexFields, resolvedFields));
       }
     });
@@ -308,26 +278,23 @@ function addNodeToFilterCache({
   node,
   chain,
   filterCache,
-  resolvedNodesCache,
   indexFields,
   resolvedFields,
   valueOffset = node
 }) {
-  // There can be a filter that targets `__gatsby_resolved` so fix that first
-  if (!node.__gatsby_resolved) {
-    const typeName = node.internal.type;
-    const resolvedNodes = resolvedNodesCache.get(typeName);
-    node.__gatsby_resolved = resolvedNodes === null || resolvedNodes === void 0 ? void 0 : resolvedNodes.get(node.id);
-  } // - for plain query, valueOffset === node
+  // - for plain query, valueOffset === node
   // - for elemMatch, valueOffset is sub-tree of the node to continue matching
-
-
   let v = valueOffset;
   let i = 0;
 
   while (i < chain.length && v) {
     const nextProp = chain[i++];
-    v = v[nextProp];
+
+    if (i === 1 && nextProp === `__gatsby_resolved`) {
+      v = (0, _utils.getResolvedFields)(v);
+    } else {
+      v = v[nextProp];
+    }
   }
 
   if (typeof v !== `string` && typeof v !== `number` && typeof v !== `boolean` && v !== null || i !== chain.length) {
@@ -367,11 +334,6 @@ function markNodeForValue(filterCache, node, value, indexFields, resolvedFields)
 const ensureIndexByElemMatch = (op, filterCacheKey, filter, nodeTypeNames, filtersCache, indexFields, resolvedFields) => {
   // Given an elemMatch filter, generate the cache that contains all nodes that
   // matches a given value for that sub-query
-  const state = _redux.store.getState();
-
-  const {
-    resolvedNodesCache
-  } = state;
   const filterCache = {
     op,
     byValue: new Map(),
@@ -386,7 +348,6 @@ const ensureIndexByElemMatch = (op, filterCacheKey, filter, nodeTypeNames, filte
         valueAtCurrentStep: node,
         filter,
         filterCache,
-        resolvedNodesCache,
         indexFields,
         resolvedFields
       });
@@ -403,7 +364,6 @@ const ensureIndexByElemMatch = (op, filterCacheKey, filter, nodeTypeNames, filte
         valueAtCurrentStep: node,
         filter,
         filterCache,
-        resolvedNodesCache,
         indexFields,
         resolvedFields
       });
@@ -421,17 +381,9 @@ function addNodeToBucketWithElemMatch({
   // Arbitrary step on the path inside the node
   filter,
   filterCache,
-  resolvedNodesCache,
   indexFields,
   resolvedFields
 }) {
-  // There can be a filter that targets `__gatsby_resolved` so fix that first
-  if (!node.__gatsby_resolved) {
-    const typeName = node.internal.type;
-    const resolvedNodes = resolvedNodesCache.get(typeName);
-    node.__gatsby_resolved = resolvedNodes === null || resolvedNodes === void 0 ? void 0 : resolvedNodes.get(node.id);
-  }
-
   const {
     path,
     nestedQuery
@@ -441,7 +393,12 @@ function addNodeToBucketWithElemMatch({
 
   while (i < path.length && valueAtCurrentStep) {
     const nextProp = path[i++];
-    valueAtCurrentStep = valueAtCurrentStep[nextProp];
+
+    if (i === 1 && nextProp === `__gatsby_resolved`) {
+      valueAtCurrentStep = (0, _utils.getResolvedFields)(valueAtCurrentStep);
+    } else {
+      valueAtCurrentStep = valueAtCurrentStep[nextProp];
+    }
   }
 
   if (path.length !== i) {
@@ -466,7 +423,6 @@ function addNodeToBucketWithElemMatch({
         valueAtCurrentStep: elem,
         filter: nestedQuery,
         filterCache,
-        resolvedNodesCache,
         indexFields,
         resolvedFields
       });
@@ -476,7 +432,6 @@ function addNodeToBucketWithElemMatch({
         node,
         chain: nestedQuery.path,
         filterCache,
-        resolvedNodesCache,
         indexFields,
         resolvedFields,
         valueOffset: elem