@depup/gatsby 5.16.1-depup.0

package/cache-dir/register-service-worker.js

@@ -0,0 +1,64 @@
+import { apiRunner } from "./api-runner-browser"
+
+if (
+  window.location.protocol !== `https:` &&
+  window.location.hostname !== `localhost`
+) {
+  console.error(
+    `Service workers can only be used over HTTPS, or on localhost for development`
+  )
+} else if (`serviceWorker` in navigator) {
+  navigator.serviceWorker
+    .register(`${__BASE_PATH__}/sw.js`)
+    .then(function (reg) {
+      reg.addEventListener(`updatefound`, () => {
+        apiRunner(`onServiceWorkerUpdateFound`, { serviceWorker: reg })
+        // The updatefound event implies that reg.installing is set; see
+        // https://w3c.github.io/ServiceWorker/#service-worker-registration-updatefound-event
+        const installingWorker = reg.installing
+        console.log(`installingWorker`, installingWorker)
+        installingWorker.addEventListener(`statechange`, () => {
+          switch (installingWorker.state) {
+            case `installed`:
+              if (navigator.serviceWorker.controller) {
+                // At this point, the old content will have been purged and the fresh content will
+                // have been added to the cache.
+
+                // We set a flag so Gatsby Link knows to refresh the page on next navigation attempt
+                window.___swUpdated = true
+                // We call the onServiceWorkerUpdateReady API so users can show update prompts.
+                apiRunner(`onServiceWorkerUpdateReady`, { serviceWorker: reg })
+
+                // If resources failed for the current page, reload.
+                if (window.___failedResources) {
+                  console.log(`resources failed, SW updated - reloading`)
+                  window.location.reload()
+                }
+              } else {
+                // At this point, everything has been precached.
+                // It's the perfect time to display a "Content is cached for offline use." message.
+                console.log(`Content is now available offline!`)
+
+                // Post to service worker that install is complete.
+                // Delay to allow time for the event listener to be added --
+                // otherwise fetch is called too soon and resources aren't cached.
+                apiRunner(`onServiceWorkerInstalled`, { serviceWorker: reg })
+              }
+              break
+
+            case `redundant`:
+              console.error(`The installing service worker became redundant.`)
+              apiRunner(`onServiceWorkerRedundant`, { serviceWorker: reg })
+              break
+
+            case `activated`:
+              apiRunner(`onServiceWorkerActive`, { serviceWorker: reg })
+              break
+          }
+        })
+      })
+    })
+    .catch(function (e) {
+      console.error(`Error during service worker registration:`, e)
+    })
+}

package/cache-dir/root.js

@@ -0,0 +1,147 @@
+import React from "react"
+import { Router, Location, BaseContext } from "@gatsbyjs/reach-router"
+import { ScrollContext } from "gatsby-react-router-scroll"
+
+import { SlicesMapContext, SlicesContext } from "./slice/context"
+import { shouldUpdateScroll, RouteUpdates } from "./navigation"
+import { apiRunner } from "./api-runner-browser"
+import loader from "./loader"
+import {
+  PageQueryStore,
+  StaticQueryStore,
+  SliceDataStore,
+} from "./query-result-store"
+import EnsureResources from "./ensure-resources"
+import FastRefreshOverlay from "./fast-refresh-overlay"
+
+// In gatsby v2 if Router is used in page using matchPaths
+// paths need to contain full path.
+// For example:
+//   - page have `/app/*` matchPath
+//   - inside template user needs to use `/app/xyz` as path
+// Resetting `basepath`/`baseuri` keeps current behaviour
+// to not introduce breaking change.
+// Remove this in v3
+const RouteHandler = props => (
+  <BaseContext.Provider
+    value={{
+      baseuri: `/`,
+      basepath: `/`,
+    }}
+  >
+    <PageQueryStore {...props} />
+  </BaseContext.Provider>
+)
+
+class LocationHandler extends React.Component {
+  render() {
+    const { location } = this.props
+
+    const slicesContext = {
+      renderEnvironment: `browser`,
+    }
+
+    if (!loader.isPageNotFound(location.pathname + location.search)) {
+      return (
+        <EnsureResources location={location}>
+          {locationAndPageResources => (
+            <SlicesContext.Provider value={slicesContext}>
+              <SlicesMapContext.Provider
+                value={locationAndPageResources.pageResources.page.slicesMap}
+              >
+                <RouteUpdates location={location}>
+                  <ScrollContext
+                    location={location}
+                    shouldUpdateScroll={shouldUpdateScroll}
+                  >
+                    <Router
+                      basepath={__BASE_PATH__}
+                      location={location}
+                      id="gatsby-focus-wrapper"
+                    >
+                      <RouteHandler
+                        path={encodeURI(
+                          (
+                            locationAndPageResources.pageResources.page
+                              .matchPath ||
+                            locationAndPageResources.pageResources.page.path
+                          ).split(`?`)[0]
+                        )}
+                        {...this.props}
+                        {...locationAndPageResources}
+                      />
+                    </Router>
+                  </ScrollContext>
+                </RouteUpdates>
+              </SlicesMapContext.Provider>
+            </SlicesContext.Provider>
+          )}
+        </EnsureResources>
+      )
+    }
+
+    const dev404PageResources = loader.loadPageSync(`/dev-404-page`)
+    const real404PageResources = loader.loadPageSync(`/404.html`)
+    let custom404
+    if (real404PageResources) {
+      custom404 = (
+        <PageQueryStore {...this.props} pageResources={real404PageResources} />
+      )
+    }
+
+    return (
+      <EnsureResources location={location}>
+        {locationAndPageResources => (
+          <SlicesContext.Provider value={slicesContext}>
+            <SlicesMapContext.Provider
+              value={locationAndPageResources.pageResources.page.slicesMap}
+            >
+              <RouteUpdates location={location}>
+                <Router
+                  basepath={__BASE_PATH__}
+                  location={location}
+                  id="gatsby-focus-wrapper"
+                >
+                  <RouteHandler
+                    path={location.pathname}
+                    location={location}
+                    pageResources={dev404PageResources}
+                    custom404={custom404}
+                  />
+                </Router>
+              </RouteUpdates>
+            </SlicesMapContext.Provider>
+          </SlicesContext.Provider>
+        )}
+      </EnsureResources>
+    )
+  }
+}
+
+const Root = () => (
+  <Location>
+    {locationContext => <LocationHandler {...locationContext} />}
+  </Location>
+)
+
+// Let site, plugins wrap the site e.g. for Redux.
+const rootWrappedWithWrapRootElement = apiRunner(
+  `wrapRootElement`,
+  { element: <Root /> },
+  <Root />,
+  ({ result, plugin }) => {
+    return { element: result }
+  }
+).pop()
+
+function RootWrappedWithOverlayAndProvider() {
+  return (
+    <FastRefreshOverlay>
+      <SliceDataStore>
+        <StaticQueryStore>{rootWrappedWithWrapRootElement}</StaticQueryStore>
+      </SliceDataStore>
+    </FastRefreshOverlay>
+  )
+}
+
+export default RootWrappedWithOverlayAndProvider

package/cache-dir/route-announcer-props.js

@@ -0,0 +1,18 @@
+// This is extracted to separate module because it's shared
+// between browser and SSR code
+export const RouteAnnouncerProps = {
+  id: `gatsby-announcer`,
+  style: {
+    position: `absolute`,
+    top: 0,
+    width: 1,
+    height: 1,
+    padding: 0,
+    overflow: `hidden`,
+    clip: `rect(0, 0, 0, 0)`,
+    whiteSpace: `nowrap`,
+    border: 0,
+  },
+  "aria-live": `assertive`,
+  "aria-atomic": `true`,
+}

package/cache-dir/server-utils/writable-as-promise.js

@@ -0,0 +1,41 @@
+import { Writable } from "stream"
+
+export class WritableAsPromise extends Writable {
+  constructor() {
+    super()
+
+    this._output = ``
+    this._deferred = {
+      promise: null,
+      resolve: null,
+      reject: null,
+    }
+    this._deferred.promise = new Promise((resolve, reject) => {
+      this._deferred.resolve = resolve
+      this._deferred.reject = reject
+    })
+  }
+
+  _write(chunk, _, next) {
+    this._output += chunk.toString()
+    next()
+  }
+
+  _destroy(error, next) {
+    if (error instanceof Error) {
+      this._deferred.reject(error)
+    } else {
+      next()
+    }
+  }
+
+  end() {
+    this._deferred.resolve(this._output)
+    this.destroy()
+  }
+
+  // disguise us as a promise
+  then(resolve, reject) {
+    return this._deferred.promise.then(resolve, reject)
+  }
+}

package/cache-dir/shadow-portal.js

@@ -0,0 +1,28 @@
+import * as React from "react"
+import { createPortal } from "react-dom"
+
+export const ShadowPortal = ({ children, identifier }) => {
+  const mountNode = React.useRef(null)
+  const portalNode = React.useRef(null)
+  const shadowNode = React.useRef(null)
+  const [, forceUpdate] = React.useState()
+
+  React.useLayoutEffect(() => {
+    const ownerDocument = mountNode.current.ownerDocument
+    portalNode.current = ownerDocument.createElement(identifier)
+    shadowNode.current = portalNode.current.attachShadow({ mode: `open` })
+    ownerDocument.body.appendChild(portalNode.current)
+    forceUpdate({})
+    return () => {
+      if (portalNode.current && portalNode.current.ownerDocument) {
+        portalNode.current.ownerDocument.body.removeChild(portalNode.current)
+      }
+    }
+  }, [])
+
+  return shadowNode.current ? (
+    createPortal(children, shadowNode.current)
+  ) : (
+    <span ref={mountNode} />
+  )
+}

package/cache-dir/slice/context.js

@@ -0,0 +1,13 @@
+import React from "react"
+
+const SlicesResultsContext = React.createContext({})
+const SlicesContext = React.createContext({})
+const SlicesMapContext = React.createContext({})
+const SlicesPropsContext = React.createContext({})
+
+export {
+  SlicesResultsContext,
+  SlicesContext,
+  SlicesMapContext,
+  SlicesPropsContext,
+}

package/cache-dir/slice/inline-slice.js

@@ -0,0 +1,34 @@
+import React, { useContext } from "react"
+import { SlicesMapContext, SlicesResultsContext } from "./context"
+
+export const InlineSlice = ({
+  sliceName,
+  allowEmpty,
+  children,
+  ...sliceProps
+}) => {
+  const slicesMap = useContext(SlicesMapContext)
+  const slicesResultsMap = useContext(SlicesResultsContext)
+  const concreteSliceName = slicesMap[sliceName]
+  const slice = slicesResultsMap.get(concreteSliceName)
+
+  if (!slice) {
+    if (allowEmpty) {
+      return null
+    } else {
+      throw new Error(
+        `Slice "${concreteSliceName}" for "${sliceName}" slot not found`
+      )
+    }
+  }
+
+  return (
+    <slice.component
+      sliceContext={slice.sliceContext}
+      data={slice.data}
+      {...sliceProps}
+    >
+      {children}
+    </slice.component>
+  )
+}

package/cache-dir/slice/server-slice-renderer.js

@@ -0,0 +1,28 @@
+import React from "react"
+
+export const ServerSliceRenderer = ({ sliceId, children }) => {
+  const contents = [
+    React.createElement(`slice-start`, {
+      id: `${sliceId}-1`,
+    }),
+    React.createElement(`slice-end`, {
+      id: `${sliceId}-1`,
+    }),
+  ]
+
+  if (children) {
+    // if children exist, we split the slice into a before and after piece
+    // see renderSlices in render-html
+    contents.push(children)
+    contents.push(
+      React.createElement(`slice-start`, {
+        id: `${sliceId}-2`,
+      }),
+      React.createElement(`slice-end`, {
+        id: `${sliceId}-2`,
+      })
+    )
+  }
+
+  return contents
+}

package/cache-dir/slice/server-slice.js

@@ -0,0 +1,52 @@
+import React, { useContext } from "react"
+import { createContentDigest } from "gatsby-core-utils/create-content-digest"
+import { SlicesMapContext, SlicesPropsContext } from "./context"
+import { ServerSliceRenderer } from "./server-slice-renderer"
+
+const getSliceId = (sliceName, sliceProps) => {
+  if (!Object.keys(sliceProps).length) {
+    return sliceName
+  }
+
+  const propsString = createContentDigest(sliceProps)
+  return `${sliceName}-${propsString}`
+}
+
+export const ServerSlice = ({
+  sliceName,
+  allowEmpty,
+  children,
+  ...sliceProps
+}) => {
+  const slicesMap = useContext(SlicesMapContext)
+  const slicesProps = useContext(SlicesPropsContext)
+  const concreteSliceName = slicesMap[sliceName]
+
+  if (!concreteSliceName) {
+    if (allowEmpty) {
+      return null
+    } else {
+      throw new Error(
+        `Slice "${concreteSliceName}" for "${sliceName}" slot not found`
+      )
+    }
+  }
+
+  const sliceId = getSliceId(concreteSliceName, sliceProps)
+
+  // set props on context object for static-entry to return
+  let sliceUsage = slicesProps[sliceId]
+  if (!sliceUsage) {
+    slicesProps[sliceId] = sliceUsage = {
+      props: sliceProps,
+      sliceName: concreteSliceName,
+      hasChildren: !!children,
+    }
+  } else {
+    if (children) {
+      sliceUsage.hasChildren = true
+    }
+  }
+
+  return <ServerSliceRenderer sliceId={sliceId}>{children}</ServerSliceRenderer>
+}

package/cache-dir/slice.js

@@ -0,0 +1,158 @@
+"use client"
+
+import React, { useContext } from "react"
+import { ServerSlice } from "./slice/server-slice"
+import { InlineSlice } from "./slice/inline-slice"
+import { SlicesContext } from "./slice/context"
+
+export function Slice(props) {
+  if (process.env.GATSBY_SLICES) {
+    // we use sliceName internally, so remap alias to sliceName
+    const internalProps = {
+      ...props,
+      sliceName: props.alias,
+    }
+    delete internalProps.alias
+    delete internalProps.__renderedByLocation
+
+    const slicesContext = useContext(SlicesContext)
+
+    // validate props
+    const propErrors = validateSliceProps(props)
+    if (Object.keys(propErrors).length) {
+      throw new SlicePropsError(
+        slicesContext.renderEnvironment === `browser`,
+        internalProps.sliceName,
+        propErrors,
+        props.__renderedByLocation
+      )
+    }
+
+    if (slicesContext.renderEnvironment === `server`) {
+      return <ServerSlice {...internalProps} />
+    } else if (slicesContext.renderEnvironment === `browser`) {
+      // in the browser, we'll just render the component as is
+      return <InlineSlice {...internalProps} />
+    } else if (
+      slicesContext.renderEnvironment === `engines` ||
+      slicesContext.renderEnvironment === `dev-ssr`
+    ) {
+      // if we're in SSR, we'll just render the component as is
+      return <InlineSlice {...internalProps} />
+    } else if (slicesContext.renderEnvironment === `slices`) {
+      // we are not yet supporting nested slices
+
+      let additionalContextMessage = ``
+
+      // just in case generating additional contextual information fails, we still want the base message to show
+      // and not show another cryptic error message
+      try {
+        additionalContextMessage = `\n\nSlice component "${slicesContext.sliceRoot.name}" (${slicesContext.sliceRoot.componentPath}) tried to render <Slice alias="${props.alias}"/>`
+      } catch {
+        // don't need to handle it, we will just skip the additional context message if we fail to generate it
+      }
+
+      throw new Error(
+        `Nested slices are not supported.${additionalContextMessage}\n\nSee https://gatsbyjs.com/docs/reference/built-in-components/gatsby-slice#nested-slices`
+      )
+    } else {
+      throw new Error(
+        `Slice context "${slicesContext.renderEnvironment}" is not supported.`
+      )
+    }
+  } else {
+    throw new Error(`Slices are disabled.`)
+  }
+}
+
+class SlicePropsError extends Error {
+  constructor(inBrowser, sliceName, propErrors, renderedByLocation) {
+    const errors = Object.entries(propErrors)
+      .map(
+        ([key, value]) =>
+          `not serializable "${value}" type passed to "${key}" prop`
+      )
+      .join(`, `)
+
+    const name = `SlicePropsError`
+    let stack = ``
+    let message = ``
+
+    if (inBrowser) {
+      let fullStack = ``
+
+      // React 19+ uses captureOwnerStack, React 18 uses ReactDebugCurrentFrame.getCurrentStack
+      if (React.captureOwnerStack) {
+        // React 19+ approach
+        const ownerStack = React.captureOwnerStack()
+        const currentStack = new Error().stack || ``
+        fullStack = ownerStack ? `${currentStack}\n${ownerStack}` : currentStack
+      } else if (
+        React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
+          ?.ReactDebugCurrentFrame?.getCurrentStack
+      ) {
+        // React 18 approach
+        fullStack =
+          React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactDebugCurrentFrame.getCurrentStack()
+      } else {
+        // Fallback if neither API is available
+        fullStack = new Error().stack || ``
+      }
+
+      // remove the first line of the stack trace
+      const stackLines = fullStack.trim().split(`\n`).slice(1)
+      if (stackLines.length > 0) {
+        stackLines[0] = stackLines[0].trim()
+        stack = `\n` + stackLines.join(`\n`)
+      }
+
+      message = `Slice "${sliceName}" was passed props that are not serializable (${errors}).`
+    } else {
+      // we can't really grab any extra info outside of the browser, so just print what we can
+      message = `${name}: Slice "${sliceName}" was passed props that are not serializable (${errors}).`
+      const stackLines = new Error().stack.trim().split(`\n`).slice(2)
+      stack = `${message}\n${stackLines.join(`\n`)}`
+    }
+
+    super(message)
+    this.name = name
+    if (stack) {
+      this.stack = stack
+    } else {
+      Error.captureStackTrace(this, SlicePropsError)
+    }
+
+    if (renderedByLocation) {
+      this.forcedLocation = { ...renderedByLocation, functionName: `Slice` }
+    }
+  }
+}
+
+const validateSliceProps = (
+  props,
+  errors = {},
+  seenObjects = [],
+  path = null
+) => {
+  // recursively validate all props
+  for (const [name, value] of Object.entries(props)) {
+    if (
+      value === undefined ||
+      value === null ||
+      (!path && name === `children`)
+    ) {
+      continue
+    }
+
+    const propPath = path ? `${path}.${name}` : name
+
+    if (typeof value === `function`) {
+      errors[propPath] = typeof value
+    } else if (typeof value === `object` && seenObjects.indexOf(value) <= 0) {
+      seenObjects.push(value)
+      validateSliceProps(value, errors, seenObjects, propPath)
+    }
+  }
+
+  return errors
+}

package/cache-dir/socketIo.js

@@ -0,0 +1,58 @@
+import io from "socket.io-client"
+import { reportError, clearError } from "./error-overlay-handler"
+let socket = null
+
+export default function socketIo() {
+  if (process.env.NODE_ENV !== `production`) {
+    if (!socket) {
+      // Try to initialize web socket if we didn't do it already
+      try {
+        // force websocket as transport
+        socket = io({
+          transports: [process.env.GATSBY_SOCKET_IO_DEFAULT_TRANSPORT],
+        })
+
+        // when websocket fails, we'll try polling
+        socket.on(`reconnect_attempt`, () => {
+          socket.io.opts.transports = [`polling`, `websocket`]
+        })
+
+        socket.on(`message`, msg => {
+          if (msg.type === `overlayError`) {
+            if (msg.payload.message) {
+              reportError(msg.payload.id, msg.payload.message)
+            } else {
+              clearError(msg.payload.id)
+            }
+            ___emitter.emit(msg.type, msg.payload)
+          }
+        })
+
+        // Prevents certain browsers spamming XHR 'ERR_CONNECTION_REFUSED'
+        // errors within the console, such as when exiting the develop process.
+        socket.on(`disconnect`, () => {
+          console.warn(`[socket.io] Disconnected from dev server.`)
+        })
+      } catch (err) {
+        console.error(`Could not connect to socket.io on dev server.`)
+      }
+    }
+    return socket
+  } else {
+    return null
+  }
+}
+
+// Tell websocket-manager.js the new path we're on.
+// This will help the backend prioritize queries for this
+// path.
+function registerPath(path) {
+  socket.emit(`registerPath`, path)
+}
+
+// Unregister the former path
+function unregisterPath(path) {
+  socket.emit(`unregisterPath`, path)
+}
+
+export { registerPath, unregisterPath }

package/cache-dir/ssr-builtin-trackers/child_process.js

@@ -0,0 +1,4 @@
+/* eslint-disable filenames/match-regex */
+const { wrapModuleWithTracking } = require(`./tracking-unsafe-module-wrapper`)
+
+module.exports = wrapModuleWithTracking(`child_process`)

package/cache-dir/ssr-builtin-trackers/fs.js

@@ -0,0 +1,3 @@
+const { wrapModuleWithTracking } = require(`./tracking-unsafe-module-wrapper`)
+
+module.exports = wrapModuleWithTracking(`fs`)

package/cache-dir/ssr-builtin-trackers/http.js

@@ -0,0 +1,3 @@
+const { wrapModuleWithTracking } = require(`./tracking-unsafe-module-wrapper`)
+
+module.exports = wrapModuleWithTracking(`http`, { ignore: [`http.Agent`] })

package/cache-dir/ssr-builtin-trackers/http2.js

@@ -0,0 +1,3 @@
+const { wrapModuleWithTracking } = require(`./tracking-unsafe-module-wrapper`)
+
+module.exports = wrapModuleWithTracking(`http2`)

package/cache-dir/ssr-builtin-trackers/https.js

@@ -0,0 +1,3 @@
+const { wrapModuleWithTracking } = require(`./tracking-unsafe-module-wrapper`)
+
+module.exports = wrapModuleWithTracking(`https`, { ignore: [`https.Agent`] })