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

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

'use strict';

var React2 = require('react');
var clientReactStreaming = require('@apollo/client-react-streaming');
var invariant = require('@apollo/client/utilities/invariant');

function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }

var React2__default = /*#__PURE__*/_interopDefault(React2);

// 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.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 = React2.useRef(
    window[ApolloHookRehydrationCache] ??= {}
  );
  registerDataTransport({
    onQueryEvent,
    onRehydrate(rehydrate) {
      Object.assign(hookRehydrationCache.current, rehydrate);
    },
    revive: reviveFromStream
  });
  React2.useEffect(() => {
    if (document.readyState !== "complete") {
      window.addEventListener("load", rerunSimulatedQueries, {
        once: true
      });
      return () => window.removeEventListener("load", rerunSimulatedQueries);
    } else {
      rerunSimulatedQueries();
    }
  }, [rerunSimulatedQueries]);
  const useStaticValueRef = React2.useCallback(function useStaticValueRef2(v) {
    const id = React2.useId();
    const store = hookRehydrationCache.current;
    const dataRef = React2.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__default.default.createElement(
    clientReactStreaming.DataTransportContext.Provider,
    {
      value: React2.useMemo(
        () => ({
          useStaticValueRef
        }),
        [useStaticValueRef]
      )
    },
    children
  );
};
var UNINITIALIZED = {};
var buildManualDataTransport = buildManualDataTransportBrowserImpl;
function resetManualSSRApolloSingletons() {
  clientReactStreaming.resetApolloSingletons();
  delete window[ApolloHookRehydrationCache];
  delete window[ApolloSSRDataTransport];
}
exports.built_for_browser = true;

exports.buildManualDataTransport = buildManualDataTransport;
exports.registerLateInitializingQueue = registerLateInitializingQueue;
exports.resetManualSSRApolloSingletons = resetManualSSRApolloSingletons;
//# sourceMappingURL=out.js.map
//# sourceMappingURL=manual-transport.browser.cjs.map