@apollo/client-react-streaming/dist/manual-transport.browser.js

This package provides building blocks to create framework-level integration of Apollo Client with React's streaming SSR. See the [@apollo/client-integration-nextjs](https://github.com/apollographql/apollo-client-integrations/tree/main/packages/nextjs) pac

import React2, { useRef, useEffect, useCallback, useId, useMemo } from 'react';
import { resetApolloSingletons, DataTransportContext } from '@apollo/client-react-streaming';
import { invariant } from '@apollo/client/utilities/invariant';

// src/ManualDataTransport/ManualDataTransport.tsx

// src/ManualDataTransport/ApolloRehydrateSymbols.tsx
var ApolloSSRDataTransport = /* @__PURE__ */ Symbol.for(
  "ApolloSSRDataTransport"
);
var ApolloHookRehydrationCache = /* @__PURE__ */ Symbol.for(
  "apollo.hookRehydrationCache"
);

// src/ManualDataTransport/lateInitializingQueue.ts
function registerLateInitializingQueue(key, callback) {
  const previousData = window[key] || [];
  if (Array.isArray(previousData)) {
    window[key] = {
      push: (...data) => {
        for (const value of data) {
          callback(value);
        }
      }
    };
    window[key].push(...previousData);
  }
}
function registerDataTransport({
  onQueryEvent,
  onRehydrate,
  revive: revive2
}) {
  registerLateInitializingQueue(ApolloSSRDataTransport, (data) => {
    const parsed = revive2(data);
    invariant.debug(`received data from the server:`, parsed);
    onRehydrate(parsed.rehydrate);
    for (const result of parsed.events) {
      onQueryEvent(result);
    }
  });
}

// src/ManualDataTransport/serialization.ts
function revive(value) {
  return value;
}

// src/ManualDataTransport/ManualDataTransport.tsx
var buildManualDataTransportBrowserImpl = ({
  reviveFromStream = revive
}) => function ManualDataTransportBrowserImpl({
  children,
  onQueryEvent,
  rerunSimulatedQueries
}) {
  const hookRehydrationCache = useRef(
    window[ApolloHookRehydrationCache] ??= {}
  );
  registerDataTransport({
    onQueryEvent,
    onRehydrate(rehydrate) {
      Object.assign(hookRehydrationCache.current, rehydrate);
    },
    revive: reviveFromStream
  });
  useEffect(() => {
    if (document.readyState !== "complete") {
      window.addEventListener("load", rerunSimulatedQueries, {
        once: true
      });
      return () => window.removeEventListener("load", rerunSimulatedQueries);
    } else {
      rerunSimulatedQueries();
    }
  }, [rerunSimulatedQueries]);
  const useStaticValueRef = useCallback(function useStaticValueRef2(v) {
    const id = useId();
    const store = hookRehydrationCache.current;
    const dataRef = useRef(UNINITIALIZED);
    if (dataRef.current === UNINITIALIZED) {
      if (store && id in store) {
        dataRef.current = store[id];
        delete store[id];
      } else {
        dataRef.current = v;
      }
    }
    return dataRef;
  }, []);
  return /* @__PURE__ */ React2.createElement(
    DataTransportContext.Provider,
    {
      value: useMemo(
        () => ({
          useStaticValueRef
        }),
        [useStaticValueRef]
      )
    },
    children
  );
};
var UNINITIALIZED = {};
var buildManualDataTransport = buildManualDataTransportBrowserImpl;
function resetManualSSRApolloSingletons() {
  resetApolloSingletons();
  delete window[ApolloHookRehydrationCache];
  delete window[ApolloSSRDataTransport];
}
const built_for_browser = true;

export { buildManualDataTransport, built_for_browser, registerLateInitializingQueue, resetManualSSRApolloSingletons };
//# sourceMappingURL=out.js.map
//# sourceMappingURL=manual-transport.browser.js.map