{"version":3,"sources":["../src/AccumulateMultipartResponsesLink.ts","../src/RemoveMultipartDirectivesLink.ts","../src/SSRMultipartLink.ts","../src/DataTransportAbstraction/WrappedInMemoryCache.tsx","../src/bundleInfo.ts","../src/DataTransportAbstraction/WrappedApolloClient.tsx","../src/DataTransportAbstraction/backpressuredCallback.ts","../src/DataTransportAbstraction/useTransportValue.tsx","../src/DataTransportAbstraction/DataTransportAbstraction.ts","../src/transportedQueryRef.ts","../src/ReadableStreamLink.tsx","../src/DataTransportAbstraction/transportedOptions.ts","../src/DataTransportAbstraction/hooks.ts","../src/assertInstance.ts","../src/DataTransportAbstraction/symbols.ts","../src/DataTransportAbstraction/testHelpers.ts","../src/DataTransportAbstraction/WrapApolloProvider.tsx"],"names":["ApolloLink","Observable","invariant","reader","WrappedApolloProvider","ApolloClientSingleton"],"mappings":"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","sourcesContent":["import { ApolloLink } from \"@apollo/client\";\nimport { Observable } from \"@apollo/client/utilities\";\nimport { hasDirectives } from \"@apollo/client/utilities/internal\";\nimport type { InternalTypes } from \"@apollo/client\";\nimport type { Incremental } from \"@apollo/client/incremental\";\nimport type { FormattedExecutionResult } from \"graphql\";\n\ninterface AccumulateMultipartResponsesConfig {\n  /**\n   * The maximum delay in milliseconds\n   * from receiving the first response\n   * until the accumulated data will be flushed\n   * and the connection will be closed.\n   */\n  cutoffDelay: number;\n}\n\n/**\n *\n * This link can be used to \"debounce\" the initial response of a multipart request. Any incremental data received during the `cutoffDelay` time will be merged into the initial response.\n *\n * After `cutoffDelay`, the link will return the initial response, even if there is still incremental data pending, and close the network connection.\n *\n * If `cutoffDelay` is `0`, the link will immediately return data as soon as it is received, without waiting for incremental data, and immediately close the network connection.\n *\n * @example\n * ```ts\n * new AccumulateMultipartResponsesLink({\n *   // The maximum delay in milliseconds\n *   // from receiving the first response\n *   // until the accumulated data will be flushed\n *   // and the connection will be closed.\n *   cutoffDelay: 100,\n *  });\n * ```\n *\n * @public\n */\nexport class AccumulateMultipartResponsesLink extends ApolloLink {\n  private maxDelay: number;\n\n  constructor(config: AccumulateMultipartResponsesConfig) {\n    super();\n    this.maxDelay = config.cutoffDelay;\n  }\n  request(\n    operation: ApolloLink.Operation,\n    forward?: ApolloLink.ForwardFunction\n  ) {\n    if (!forward) {\n      throw new Error(\"This is not a terminal link!\");\n    }\n\n    const operationContainsMultipartDirectives = hasDirectives(\n      [\"defer\"],\n      operation.query\n    );\n\n    const upstream = forward(operation);\n    if (!operationContainsMultipartDirectives) return upstream;\n\n    // TODO: this could be overwritten with a `@AccumulateMultipartResponsesConfig(maxDelay: 1000)` directive on the operation\n    const maxDelay = this.maxDelay;\n    let accumulatedData: FormattedExecutionResult | undefined,\n      maxDelayTimeout: NodeJS.Timeout;\n    const incrementalHandler = (\n      operation.client[\"queryManager\"] as InternalTypes.QueryManager\n    ).incrementalHandler;\n    let incremental: Incremental.IncrementalRequest<\n      Record<string, unknown>,\n      Record<string, unknown>\n    >;\n\n    return new Observable<ApolloLink.Result>((subscriber) => {\n      const upstreamSubscription = upstream.subscribe({\n        next: (result) => {\n          if (incrementalHandler.isIncrementalResult(result)) {\n            incremental ||= incrementalHandler.startRequest({\n              query: operation.query,\n            });\n            accumulatedData = incremental.handle(accumulatedData?.data, result);\n          } else {\n            accumulatedData = result;\n          }\n          if (!maxDelay) {\n            flushAccumulatedData();\n          } else if (!maxDelayTimeout) {\n            maxDelayTimeout = setTimeout(flushAccumulatedData, maxDelay);\n          }\n        },\n        error: (error) => {\n          if (maxDelayTimeout) clearTimeout(maxDelayTimeout);\n          subscriber.error(error);\n        },\n        complete: () => {\n          if (maxDelayTimeout) {\n            clearTimeout(maxDelayTimeout);\n            flushAccumulatedData();\n          }\n          subscriber.complete();\n        },\n      });\n\n      function flushAccumulatedData() {\n        if (accumulatedData) {\n          subscriber.next(accumulatedData);\n        }\n        subscriber.complete();\n        upstreamSubscription.unsubscribe();\n      }\n\n      return function cleanUp() {\n        clearTimeout(maxDelayTimeout);\n        upstreamSubscription.unsubscribe();\n      };\n    });\n  }\n}\n","import type { DocumentNode } from \"@apollo/client\";\nimport { ApolloLink } from \"@apollo/client\";\nimport { removeDirectivesFromDocument } from \"@apollo/client/utilities/internal\";\nimport type { DirectiveNode } from \"graphql\";\nimport { of } from \"rxjs\";\n\ninterface RemoveMultipartDirectivesConfig {\n  /**\n   * Whether to strip fragments with `@defer` directives\n   * from queries before sending them to the server.\n   *\n   * Defaults to `true`.\n   *\n   * Can be overwritten by adding a label starting\n   * with either `\"SsrDontStrip\"` or `\"SsrStrip\"` to the\n   * directive.\n   */\n  stripDefer?: boolean;\n}\n\nfunction getDirectiveArgumentValue(directive: DirectiveNode, argument: string) {\n  return directive.arguments?.find((arg: any) => arg.name.value === argument)\n    ?.value;\n}\n/**\n * This link will (if called with `stripDefer: true`) strip all `@defer` fragments from your query.\n *\n * This is used to prevent the server from doing additional work in SSR scenarios where multipart responses cannot be handled anyways.\n *\n * You can exclude certain fragments from this behavior by giving them a label starting with `\"SsrDontStrip\"`.\n * The \"starting with\" is important, because labels have to be unique per operation. So if you have multiple directives where you want to override the default stipping behaviour,\n * you can do this by annotating them like\n * ```graphql\n * query myQuery {\n *   fastField\n *   ... @defer(label: \"SsrDontStrip1\") {\n *     slowField1\n *   }\n *   ... @defer(label: \"SsrDontStrip2\") {\n *     slowField2\n *   }\n * }\n * ```\n *\n * You can also use the link with `stripDefer: false` and mark certain fragments to be stripped by giving them a label starting with `\"SsrStrip\"`.\n *\n * @example\n * ```ts\n * new RemoveMultipartDirectivesLink({\n *   // Whether to strip fragments with `@defer` directives\n *   // from queries before sending them to the server.\n *   //\n *   // Defaults to `true`.\n *   //\n *   // Can be overwritten by adding a label starting\n *   // with either `\"SsrDontStrip\"` or `\"SsrStrip\"` to the\n *   // directive.\n *   stripDefer: true,\n * });\n * ```\n *\n * @public\n */\nexport class RemoveMultipartDirectivesLink extends ApolloLink {\n  private stripDirectives: string[] = [];\n  constructor(config: RemoveMultipartDirectivesConfig) {\n    super();\n\n    if (config.stripDefer !== false) this.stripDirectives.push(\"defer\");\n  }\n\n  request(\n    operation: ApolloLink.Operation,\n    forward?: ApolloLink.ForwardFunction\n  ) {\n    if (!forward) {\n      throw new Error(\"This is not a terminal link!\");\n    }\n    const { query } = operation;\n\n    let modifiedQuery: DocumentNode | null = query;\n    modifiedQuery = removeDirectivesFromDocument(\n      this.stripDirectives\n        .map<Parameters<typeof removeDirectivesFromDocument>[0][0]>(\n          (directive) => ({\n            test(node) {\n              let shouldStrip =\n                node.kind === \"Directive\" && node.name.value === directive;\n              const label = getDirectiveArgumentValue(node, \"label\");\n              if (\n                label?.kind === \"StringValue\" &&\n                label.value.startsWith(\"SsrDontStrip\")\n              ) {\n                shouldStrip = false;\n              }\n              return shouldStrip;\n            },\n            remove: true,\n          })\n        )\n        .concat({\n          test(node) {\n            if (node.kind !== \"Directive\") return false;\n            const label = getDirectiveArgumentValue(node, \"label\");\n            return (\n              label?.kind === \"StringValue\" &&\n              label.value.startsWith(\"SsrStrip\")\n            );\n          },\n          remove: true,\n        }),\n      modifiedQuery\n    );\n\n    if (modifiedQuery === null) {\n      return of({});\n    }\n\n    operation.query = modifiedQuery;\n\n    return forward(operation);\n  }\n}\n","import { ApolloLink } from \"@apollo/client\";\nimport { RemoveMultipartDirectivesLink } from \"./RemoveMultipartDirectivesLink.js\";\nimport { AccumulateMultipartResponsesLink } from \"./AccumulateMultipartResponsesLink.js\";\n\ninterface SSRMultipartLinkConfig {\n  /**\n   * Whether to strip fragments with `@defer` directives\n   * from queries before sending them to the server.\n   *\n   * Defaults to `true`.\n   *\n   * Can be overwritten by adding a label starting\n   * with either `\"SsrDontStrip\"` or `\"SsrStrip\"` to the\n   * directive.\n   */\n  stripDefer?: boolean;\n  /**\n   * The maximum delay in milliseconds\n   * from receiving the first response\n   * until the accumulated data will be flushed\n   * and the connection will be closed.\n   *\n   * Defaults to `0`.\n   */\n  cutoffDelay?: number;\n}\n\n/**\n * A convenient combination of `RemoveMultipartDirectivesLink` and `AccumulateMultipartResponsesLink`.\n *\n * @example\n * ```ts\n * new SSRMultipartLink({\n *   // Whether to strip fragments with `@defer` directives\n *   // from queries before sending them to the server.\n *   //\n *   // Defaults to `true`.\n *   //\n *   // Can be overwritten by adding a label starting\n *   // with either `\"SsrDontStrip\"` or `\"SsrStrip\"` to the\n *   // directive.\n *   stripDefer: true,\n *   // The maximum delay in milliseconds\n *   // from receiving the first response\n *   // until the accumulated data will be flushed\n *   // and the connection will be closed.\n *   //\n *   // Defaults to `0`.\n *   //\n *   cutoffDelay: 100,\n * });\n * ```\n *\n * @public\n */\nexport class SSRMultipartLink extends ApolloLink {\n  constructor(config: SSRMultipartLinkConfig = {}) {\n    const combined = ApolloLink.from([\n      new RemoveMultipartDirectivesLink({\n        stripDefer: config.stripDefer,\n      }),\n      new AccumulateMultipartResponsesLink({\n        cutoffDelay: config.cutoffDelay || 0,\n      }),\n    ]);\n    super(combined.request);\n  }\n}\n","import type { InMemoryCacheConfig } from \"@apollo/client\";\nimport { InMemoryCache as OrigInMemoryCache } from \"@apollo/client\";\nimport { bundle, sourceSymbol } from \"../bundleInfo.js\";\n/*\n * We just subclass `InMemoryCache` here so that `WrappedApolloClient`\n * can detect if it was initialized with an `InMemoryCache` instance that\n * was also exported from this package.\n * Right now, we don't have extra logic here, but we might have so again\n * in the future.\n * So we want to enforce this import path from the start to prevent future\n * subtle bugs if people update the package and don't read the patch notes.\n */\n/**\n * A version of `InMemoryCache` to be used with streaming SSR.\n *\n * For more documentation, please see {@link https://www.apollographql.com/docs/react/api/cache/InMemoryCache | the Apollo Client API documentation}.\n *\n * @public\n */\nexport class InMemoryCache extends OrigInMemoryCache {\n  /**\n   * Information about the current package and it's export names, for use in error messages.\n   *\n   * @internal\n   */\n  static readonly info = bundle;\n  [sourceSymbol]: string;\n  constructor(config?: InMemoryCacheConfig | undefined) {\n    super(config);\n    const info = (this.constructor as typeof InMemoryCache).info;\n    this[sourceSymbol] = `${info.pkg}:InMemoryCache`;\n  }\n}\n","export const bundle = {\n  pkg: \"@apollo/client-react-streaming\",\n};\n\nexport const sourceSymbol = Symbol.for(\"apollo.source_package\");\n","import type { OperationVariables } from \"@apollo/client\";\n\nimport {\n  ApolloLink,\n  ApolloClient as OrigApolloClient,\n  Observable,\n  type InternalTypes,\n} from \"@apollo/client\";\nimport { invariant } from \"@apollo/client/utilities/invariant\";\nimport { createBackpressuredCallback } from \"./backpressuredCallback.js\";\nimport type { InMemoryCache } from \"./WrappedInMemoryCache.js\";\nimport { hookWrappers } from \"./hooks.js\";\nimport type { HookWrappers } from \"@apollo/client/react/internal\";\nimport type {\n  ProgressEvent,\n  QueryEvent,\n  TransportIdentifier,\n} from \"./DataTransportAbstraction.js\";\nimport { bundle, sourceSymbol } from \"../bundleInfo.js\";\nimport { serializeOptions, deserializeOptions } from \"./transportedOptions.js\";\nimport { assertInstance } from \"../assertInstance.js\";\nimport type { ReadableStreamLinkEvent } from \"../ReadableStreamLink.js\";\nimport {\n  readFromReadableStream,\n  ReadFromReadableStreamLink,\n  teeToReadableStream,\n  TeeToReadableStreamLink,\n} from \"../ReadableStreamLink.js\";\nimport { getInjectableEventStream } from \"../transportedQueryRef.js\";\n\nfunction getQueryManager(\n  client: OrigApolloClient\n): InternalTypes.QueryManager & {\n  [wrappers]: HookWrappers;\n} {\n  return client[\"queryManager\"];\n}\n\ntype SimulatedQueryInfo = {\n  controller: ReadableStreamDefaultController<ReadableStreamLinkEvent>;\n  options: OrigApolloClient.WatchQueryOptions<any, OperationVariables>;\n};\n/** @public */\nexport declare namespace ApolloClient {\n  /** @public */\n  export interface Options\n    extends Omit<\n      OrigApolloClient.Options,\n      \"cache\" | \"ssrMode\" | \"ssrForceFetchDelay\"\n    > {\n    cache: InMemoryCache;\n  }\n  /*\n  We can currently not re-export these types from the upstream ApolloClient implementation because the build \n  tooling doesn't support that:\n    > DTS Build error\n    > Error: namespace child (hoisting) not supported yet\n\n    We could re-export them by defining them as new types that reference the originals, but that would require us\n    to keep generics in sync and would either erase the docblocks or require us to duplicate them \n    (and they would go out of sync).\n    If you need any of the other types, please use the `ApolloClient` namespace exported from `@apollo/client` directly.\n  */\n  // export import DefaultOptions = OrigApolloClient.DefaultOptions;\n  // export import DevtoolsOptions = OrigApolloClient.DevtoolsOptions;\n  // export import MutateOptions = OrigApolloClient.MutateOptions;\n  // export import MutateResult = OrigApolloClient.MutateResult;\n  // export import QueryOptions = OrigApolloClient.QueryOptions;\n  // export import QueryResult = OrigApolloClient.QueryResult;\n  // export import RefetchQueriesOptions = OrigApolloClient.RefetchQueriesOptions;\n  // export import RefetchQueriesResult = OrigApolloClient.RefetchQueriesResult;\n  // export import SubscribeOptions = OrigApolloClient.SubscribeOptions;\n  // export import SubscribeResult = OrigApolloClient.SubscribeResult;\n  // export import WatchFragmentOptions = OrigApolloClient.WatchFragmentOptions;\n  // export import WatchFragmentResult = OrigApolloClient.WatchFragmentResult;\n  // export import WatchQueryOptions = OrigApolloClient.WatchQueryOptions;\n  // export import ReadQueryOptions = OrigApolloClient.ReadQueryOptions;\n  // export import WriteQueryOptions = OrigApolloClient.WriteQueryOptions;\n  // export import WriteFragmentOptions = OrigApolloClient.WriteFragmentOptions;\n}\n\nconst wrappers = Symbol.for(\"apollo.hook.wrappers\");\nclass ApolloClientBase extends OrigApolloClient {\n  /**\n   * Information about the current package and it's export names, for use in error messages.\n   *\n   * @internal\n   */\n  static readonly info = bundle;\n\n  [sourceSymbol]: string;\n\n  constructor(options: ApolloClient.Options) {\n    const warnings: string[] = [];\n    if (\"ssrMode\" in options) {\n      delete options.ssrMode;\n      warnings.push(\n        \"The `ssrMode` option is not supported in %s. Please remove it from your %s constructor options.\"\n      );\n    }\n    if (\"ssrForceFetchDelay\" in options) {\n      delete options.ssrForceFetchDelay;\n      warnings.push(\n        \"The `ssrForceFetchDelay` option is not supported in %s. Please remove it from your %s constructor options.\"\n      );\n    }\n    super(\n      process.env.REACT_ENV === \"rsc\" || process.env.REACT_ENV === \"ssr\"\n        ? {\n            devtools: { enabled: false, ...options.devtools },\n            ...options,\n          }\n        : options\n    );\n    const info = (this.constructor as typeof ApolloClientBase).info;\n    this[sourceSymbol] = `${info.pkg}:ApolloClient`;\n\n    for (const warning of warnings) {\n      console.warn(warning, info.pkg, \"ApolloClient\");\n    }\n\n    assertInstance(\n      this.cache as unknown as InMemoryCache,\n      info,\n      \"InMemoryCache\"\n    );\n\n    this.setLink(this.link);\n  }\n\n  setLink(newLink: ApolloLink) {\n    super.setLink.call(\n      this,\n      ApolloLink.from([\n        new ReadFromReadableStreamLink(),\n        new TeeToReadableStreamLink(),\n        newLink,\n      ])\n    );\n  }\n}\n\nclass ApolloClientClientBaseImpl extends ApolloClientBase {\n  constructor(options: ApolloClient.Options) {\n    super(options);\n    this.onQueryStarted = this.onQueryStarted.bind(this);\n\n    getQueryManager(this)[wrappers] = hookWrappers;\n  }\n\n  private simulatedStreamingQueries = new Map<\n    TransportIdentifier,\n    SimulatedQueryInfo\n  >();\n\n  onQueryStarted({ options, id }: Extract<QueryEvent, { type: \"started\" }>) {\n    const hydratedOptions = deserializeOptions(options);\n\n    const [controller, stream] = getInjectableEventStream();\n\n    const queryManager = getQueryManager(this);\n    queryManager.fetchQuery({\n      ...hydratedOptions,\n      query: queryManager.transform(hydratedOptions.query),\n      fetchPolicy: \"network-only\",\n      context: skipDataTransport(\n        readFromReadableStream(stream, {\n          ...hydratedOptions.context,\n          queryDeduplication: true,\n        })\n      ),\n    });\n\n    this.simulatedStreamingQueries.set(id, {\n      controller,\n      options: hydratedOptions,\n    });\n  }\n\n  onQueryProgress = (event: ProgressEvent) => {\n    const queryInfo = this.simulatedStreamingQueries.get(event.id);\n    if (!queryInfo) return;\n\n    const handler = getQueryManager(this).incrementalHandler;\n    if (\n      event.type === \"error\" ||\n      (event.type === \"next\" &&\n        (handler.isIncrementalResult(event.value)\n          ? handler.extractErrors(event.value)\n          : event.value.errors))\n    ) {\n      /**\n       * At this point we're not able to correctly serialize the error over the wire\n       * so we do the next-best thing: restart the query in the browser as soon as it\n       * failed on the server.\n       * This matches up with what React will be doing (abort hydration and rerender)\n       * See https://github.com/apollographql/apollo-client-integrations/issues/52\n       */\n      this.simulatedStreamingQueries.delete(event.id);\n      if (process.env.REACT_ENV === \"browser\") {\n        invariant.debug(\n          \"Query failed on server, rerunning in browser:\",\n          queryInfo.options\n        );\n        this.rerunSimulatedQuery(queryInfo);\n      } else if (process.env.REACT_ENV === \"ssr\") {\n        invariant.debug(\n          \"Query failed upstream, will fail it during SSR and rerun it in the browser:\",\n          queryInfo.options\n        );\n        queryInfo.controller.error(new Error(\"Query failed upstream.\"));\n      }\n    } else if (event.type === \"completed\") {\n      this.simulatedStreamingQueries.delete(event.id);\n      queryInfo.controller.enqueue(event);\n    } else if (event.type === \"next\") {\n      queryInfo.controller.enqueue(event);\n    }\n  };\n\n  /**\n   * Can be called when the stream closed unexpectedly while there might still be unresolved\n   * simulated server-side queries going on.\n   * Those queries will be cancelled and then re-run in the browser.\n   */\n  rerunSimulatedQueries = () => {\n    for (const [id, queryInfo] of this.simulatedStreamingQueries) {\n      this.simulatedStreamingQueries.delete(id);\n      invariant.debug(\n        \"streaming connection closed before server query could be fully transported, rerunning:\",\n        queryInfo.options\n      );\n      this.rerunSimulatedQuery(queryInfo);\n    }\n  };\n  rerunSimulatedQuery = (queryInfo: SimulatedQueryInfo) => {\n    const queryManager = getQueryManager(this);\n    queryManager.fetchQuery({\n      ...queryInfo.options,\n      fetchPolicy: \"no-cache\",\n      query: queryManager.transform(queryInfo.options.query),\n      context: skipDataTransport(\n        teeToReadableStream(() => queryInfo.controller, {\n          ...queryInfo.options.context,\n          queryDeduplication: false,\n        })\n      ),\n    });\n  };\n}\n\nconst skipDataTransportKey = Symbol.for(\"apollo.dataTransport.skip\");\ninterface InternalContext {\n  [skipDataTransportKey]?: boolean;\n}\n\n/**\n * Apply to a context to prevent this operation from being transported over the SSR data transport mechanism.\n * @public\n */\nexport function skipDataTransport<T extends Record<string, any>>(\n  context: T\n): T & InternalContext {\n  return Object.assign(context, {\n    [skipDataTransportKey]: true,\n  });\n}\n\nclass ApolloClientSSRImpl extends ApolloClientClientBaseImpl {\n  watchQueryQueue = createBackpressuredCallback<{\n    event: Extract<QueryEvent, { type: \"started\" }>;\n    observable: Observable<Exclude<QueryEvent, { type: \"started\" }>>;\n  }>();\n\n  pushEventStream(\n    options: OrigApolloClient.WatchQueryOptions<any, any>\n  ): ReadableStreamDefaultController<ReadableStreamLinkEvent> {\n    const id = crypto.randomUUID() as TransportIdentifier;\n\n    const [controller, eventStream] = getInjectableEventStream();\n\n    const streamObservable = new Observable<\n      Exclude<QueryEvent, { type: \"started\" }>\n    >((subscriber) => {\n      function consume(\n        event: ReadableStreamReadResult<ReadableStreamLinkEvent>\n      ) {\n        const value = event.value;\n        if (value) {\n          subscriber.next({ ...value, id });\n        }\n        if (event.done) {\n          subscriber.complete();\n        } else {\n          reader.read().then(consume);\n        }\n      }\n      const reader = eventStream.getReader();\n      reader.read().then(consume);\n    });\n\n    this.watchQueryQueue.push({\n      event: {\n        type: \"started\",\n        options: serializeOptions(options),\n        id,\n      },\n      observable: streamObservable,\n    });\n\n    return controller;\n  }\n\n  watchQuery<\n    TData = any,\n    TVariables extends OperationVariables = OperationVariables,\n  >(options: OrigApolloClient.WatchQueryOptions<TData, TVariables>) {\n    if (\n      !(options.context as InternalContext | undefined)?.[skipDataTransportKey]\n    ) {\n      return super.watchQuery({\n        ...options,\n        context: teeToReadableStream(\n          () =>\n            this.pushEventStream(\n              options as OrigApolloClient.WatchQueryOptions<any, any>\n            ),\n          {\n            ...options?.context,\n          }\n        ),\n      });\n    }\n    return super.watchQuery(options);\n  }\n}\n\nclass ApolloClientBrowserImpl extends ApolloClientClientBaseImpl {}\n\nclass ApolloClientRSCImpl extends ApolloClientBase {}\n\nconst ApolloClientImplementation =\n  /*#__PURE__*/ process.env.REACT_ENV === \"ssr\"\n    ? ApolloClientSSRImpl\n    : process.env.REACT_ENV === \"browser\"\n      ? ApolloClientBrowserImpl\n      : ApolloClientRSCImpl;\n\n/**\n * A version of `ApolloClient` to be used with streaming SSR or in React Server Components.\n *\n * For more documentation, please see {@link https://www.apollographql.com/docs/react/api/core/ApolloClient | the Apollo Client API documentation}.\n *\n * @public\n */\nexport class ApolloClient\n  extends (ApolloClientImplementation as typeof ApolloClientBase)\n  implements Partial<ApolloClientSSRImpl>\n{\n  /** @internal */\n  declare onQueryStarted?: ApolloClientSSRImpl[\"onQueryStarted\"];\n  /** @internal */\n  declare onQueryProgress?: ApolloClientSSRImpl[\"onQueryProgress\"];\n  /** @internal */\n  declare rerunSimulatedQueries?: ApolloClientSSRImpl[\"rerunSimulatedQueries\"];\n  /** @internal */\n  declare rerunSimulatedQuery?: ApolloClientSSRImpl[\"rerunSimulatedQuery\"];\n  /** @internal */\n  declare watchQueryQueue?: ApolloClientSSRImpl[\"watchQueryQueue\"];\n}\n","/**\n * Creates a callback with backpressure support.\n *\n * New calls can be made with `callback.push(value)`.\n * If a callback is already registered, it will be called directly.\n * Otherwise, the calls will be queued until a callback is registered,\n * at which point all queued calls will be executed.\n *\n * The callback can be registered with `callback.register(callback)`.\n *\n * Registering `null` as a callback will clear the current callback -\n * future calls after that will be queued again.\n */\nexport function createBackpressuredCallback<T>() {\n  const queue: T[] = [];\n  let push: (value: T) => void = queue.push.bind(queue);\n  return {\n    push: (value: T) => push(value),\n    register: (callback: null | ((value: T) => void)) => {\n      if (callback) {\n        push = callback;\n        while (queue.length) {\n          callback(queue.shift()!);\n        }\n      } else {\n        push = queue.push.bind(queue);\n      }\n    },\n  };\n}\n","\"use client\";\nimport { useContext, useSyncExternalStore } from \"react\";\nimport { DataTransportContext } from \"./DataTransportAbstraction.js\";\nimport { equal } from \"@wry/equality\";\n\nconst CLEAN = {};\nconst enum WhichResult {\n  client,\n  server,\n}\n\n/**\n * A hook that mostly acts as an identity function.\n * It will only behave differently during\n * the first render on the client, in which case it will\n * try to return the last value it was called with by\n * the same component during SSR. If that is successful,\n * it will schedule another rerender, to after hydration\n * the component can change to client-side values instead.\n */\nexport function useTransportValue<T>(value: T): T {\n  const dataTransport = useContext(DataTransportContext);\n  if (!dataTransport)\n    throw new Error(\n      \"useTransportValue must be used within a streaming-specific ApolloProvider\"\n    );\n  const valueRef = dataTransport.useStaticValueRef<T | typeof CLEAN>(value);\n\n  const whichResult = useSyncExternalStore(\n    () => () => {},\n    () => WhichResult.client,\n    () =>\n      valueRef.current === CLEAN\n        ? WhichResult.client\n        : equal(value, valueRef.current)\n          ? WhichResult.client\n          : WhichResult.server\n  );\n\n  if (whichResult === WhichResult.client) {\n    // this value will never be used again\n    // so we can safely delete it to save memory\n    valueRef.current = CLEAN;\n  }\n\n  return whichResult === WhichResult.server ? (valueRef.current as T) : value;\n}\n","import type React from \"react\";\nimport type { Observable } from \"@apollo/client\";\nimport { createContext } from \"react\";\nimport type { TransportedOptions } from \"./transportedOptions.js\";\nimport type { ReadableStreamLinkEvent } from \"../ReadableStreamLink.ts\";\n\ninterface DataTransportAbstraction {\n  /**\n   * This hook should always return the first value it was called with.\n   *\n   * If used in the browser and SSR happened, it should return the value passed to it on the server.\n   */\n  useStaticValueRef<T>(value: T): { current: T };\n}\n\n/**\n * > This export is only available in React Client Components\n *\n * If you create a custom data transport, you need to wrap the child tree in a\n * `DataTransportContext.Provider` and provide the `DataTransportAbstraction` to it.\n *\n * See for example\n * https://github.com/apollographql/apollo-client-integrations/blob/37feeaa9aea69b90a974eb9cd0fbd636b62d841a/integration-test/experimental-react/src/WrappedApolloProvider.tsx\n *\n * @public\n */\nexport const DataTransportContext =\n  /*#__PURE__*/ createContext<DataTransportAbstraction | null>(null);\n\n/**\n * Interface to be implemented by a custom data transport component,\n * for usage with `WrapApolloProvider`.\n *\n * This component needs to provide a `DataTransportContext` to it's children.\n *\n * See for example\n * https://github.com/apollographql/apollo-client-integrations/blob/37feeaa9aea69b90a974eb9cd0fbd636b62d841a/integration-test/experimental-react/src/WrappedApolloProvider.tsx\n *\n * @public\n */\nexport type DataTransportProviderImplementation<\n  // eslint-disable-next-line @typescript-eslint/ban-types\n  ExtraProps = {},\n> = React.FC<\n  {\n    /** will be present in the Browser */\n    onQueryEvent?: (event: QueryEvent) => void;\n    /** will be present in the Browser */\n    rerunSimulatedQueries?: () => void;\n    /** will be present during SSR */\n    registerDispatchRequestStarted?: (\n      callback: (query: {\n        event: Extract<QueryEvent, { type: \"started\" }>;\n        observable: Observable<Exclude<QueryEvent, { type: \"started\" }>>;\n      }) => void\n    ) => void;\n    /** will always be present */\n    children: React.ReactNode;\n  } & ExtraProps\n>;\n\nexport type TransportIdentifier = string & { __transportIdentifier: true };\n\n/**\n * Events that will be emitted by a wrapped ApolloClient instance during\n * SSR on `DataTransportProviderImplementation.registerDispatchRequestStarted`,\n * to be transported to the browser and replayed there using\n * `DataTransportProviderImplementation.onQueryEvent`.\n *\n * @public\n */\nexport type QueryEvent =\n  | {\n      type: \"started\";\n      options: TransportedOptions;\n      id: TransportIdentifier;\n    }\n  | (ReadableStreamLinkEvent & {\n      id: TransportIdentifier;\n    });\n\nexport type ProgressEvent = Exclude<QueryEvent, { type: \"started\" }>;\n","import { unwrapQueryRef, wrapQueryRef } from \"@apollo/client/react/internal\";\nimport {\n  readFromReadableStream,\n  teeToReadableStream,\n} from \"./ReadableStreamLink.js\";\nimport { skipDataTransport } from \"./DataTransportAbstraction/index.js\";\nimport type { ReadableStreamLinkEvent } from \"./ReadableStreamLink.js\";\nimport type { QueryRef } from \"@apollo/client/react\";\nimport { useApolloClient } from \"@apollo/client/react\";\nimport type {\n  DocumentNode,\n  ApolloClient,\n  OperationVariables,\n  TypedDocumentNode,\n} from \"@apollo/client\";\nimport {\n  serializeOptions,\n  deserializeOptions,\n  type TransportedOptions,\n} from \"./DataTransportAbstraction/transportedOptions.js\";\nimport { useEffect } from \"react\";\nimport {\n  JSONDecodeStream,\n  JSONEncodeStream,\n  type JsonString,\n} from \"@apollo/client-react-streaming/stream-utils\";\nimport { InternalQueryReference } from \"@apollo/client/react/internal\";\nimport { invariant } from \"@apollo/client/utilities/invariant\";\nimport { __DEV__ } from \"@apollo/client/utilities/environment\";\nimport { Kind, visit } from \"graphql\";\n\ntype RestrictedPreloadOptions = {\n  fetchPolicy?: \"network-only\" | \"cache-and-network\" | \"cache-first\";\n  returnPartialData?: false;\n  nextFetchPolicy?: undefined;\n  pollInterval?: undefined;\n};\n\n/** @public */\nexport type PreloadTransportedQueryOptions<\n  TData,\n  TVariables extends OperationVariables,\n> = Omit<ApolloClient.QueryOptions<TData, TVariables>, \"query\"> &\n  RestrictedPreloadOptions;\n\ntype TransportedQueryRefOptions = TransportedOptions & RestrictedPreloadOptions;\n\n/**\n * A `TransportedQueryRef` is an opaque object accessible via renderProp within `PreloadQuery`.\n *\n * A child client component reading the `TransportedQueryRef` via useReadQuery will suspend until the promise resolves.\n *\n * @public\n */\nexport interface TransportedQueryRef<\n  TData = unknown,\n  TVariables extends OperationVariables = OperationVariables,\n> extends QueryRef<TData, TVariables> {\n  /**\n   * Temporarily disabled - see https://github.com/apollographql/apollo-client-integrations/issues/332\n   *\n   * Will now be be `undefined` both in React Server Components and Client Components until we can find a better resolution.\n   */\n  toPromise?: undefined;\n  /** @internal */\n  $__apollo_queryRef: {\n    options: TransportedQueryRefOptions;\n    stream: ReadableStream<JsonString<ReadableStreamLinkEvent>>;\n    /**\n     * A unique key for this query, to ensure it is only hydrated once,\n     * even if it should get transported over the wire in a way that results\n     * in multiple objects describing the same queryRef.\n     * This key will be used to store the queryRef in the suspence cache.\n     *\n     * The chances of this happening should be slim (it is handled within\n     * React thanks to https://github.com/facebook/react/pull/28996), but\n     * as we use transported queryRefs with multiple frameworks with distinct\n     * transport mechanisms, this seems like a safe option.\n     */\n    queryKey: string;\n  };\n}\n\n/** @public */\nexport interface PreloadTransportedQueryFunction {\n  <TData = unknown, TVariables extends OperationVariables = OperationVariables>(\n    query: DocumentNode | TypedDocumentNode<TData, TVariables>,\n    options?: PreloadTransportedQueryOptions<TData, NoInfer<TVariables>>\n  ): TransportedQueryRef<TData, TVariables>;\n}\n\n/** @internal */\nexport function getInjectableEventStream() {\n  let controller:\n    | ReadableStreamDefaultController<ReadableStreamLinkEvent>\n    | undefined;\n  const stream = new ReadableStream<ReadableStreamLinkEvent>({\n    start(c) {\n      controller = c;\n    },\n  });\n  return [controller!, stream] as const;\n}\n\n/** @public */\nexport function createTransportedQueryPreloader(\n  client: ApolloClient,\n  {\n    prepareForReuse = false,\n    notTransportedOptionOverrides = {},\n  }:\n    | {\n        /**\n         * Set this to `true` to indicate that this `queryRef` will be reused within the same process with the same Apollo Client instance without being dehydrated and hydrated.\n         * In that case, it will already be written to the suspense cache so it doesn't need to be hydrated by re-running the query with a fake network request.\n         */\n        prepareForReuse?: boolean;\n        notTransportedOptionOverrides?: never;\n      }\n    | {\n        prepareForReuse?: never;\n        /**\n         * Overrides to the options that should happen only in the `preloader` call, but should not be transported/hydrated on the client.\n         */\n        notTransportedOptionOverrides?: Partial<\n          ApolloClient.WatchQueryOptions<any, any>\n        >;\n      } = {}\n): PreloadTransportedQueryFunction {\n  return (...[query, options]: Parameters<PreloadTransportedQueryFunction>) => {\n    // unset options that we do not support\n    options = { ...options };\n    delete options.returnPartialData;\n    delete options.nextFetchPolicy;\n    delete options.pollInterval;\n\n    const [controller, stream] = getInjectableEventStream();\n    const transportedQueryRef = createTransportedQueryRef<any, any>(\n      query,\n      options,\n      crypto.randomUUID(),\n      stream\n    );\n\n    const watchQueryOptions: ApolloClient.WatchQueryOptions<any, any> = {\n      query,\n      ...options,\n      notifyOnNetworkStatusChange: false,\n      context: skipDataTransport(\n        teeToReadableStream(() => controller, {\n          ...options?.context,\n          // we want to do this even if the query is already running for another reason\n          queryDeduplication: false,\n        })\n      ),\n      ...notTransportedOptionOverrides,\n    };\n\n    if (notTransportedOptionOverrides?.fetchPolicy === \"no-cache\") {\n      // If the `fetchPolicy` is overwritten to `no-cache`, we don't want to\n      // provoke the warning about masked fields in a no-cache query.\n      // `QueryManager` will strip these `@unmask` directives to get `serverQuery`\n      // before query deduplication hits, so this will still deduplicate fine.\n      watchQueryOptions.query = unmask(\n        client.documentTransform.transformDocument(query)\n      );\n    }\n\n    if (\n      watchQueryOptions.fetchPolicy !== \"no-cache\" &&\n      watchQueryOptions.fetchPolicy !== \"network-only\" &&\n      (!prepareForReuse ||\n        watchQueryOptions.fetchPolicy !== \"cache-and-network\")\n    ) {\n      // ensure that this query makes it to the network\n      watchQueryOptions.fetchPolicy = \"network-only\";\n    }\n\n    if (prepareForReuse) {\n      const internalQueryRef = getInternalQueryRef(\n        client,\n        { query, ...options },\n        watchQueryOptions\n      );\n\n      return Object.assign(transportedQueryRef, wrapQueryRef(internalQueryRef));\n    } else {\n      const subscription = client.watchQuery(watchQueryOptions).subscribe({\n        next() {\n          subscription.unsubscribe();\n        },\n      });\n    }\n\n    return transportedQueryRef;\n  };\n}\n\nfunction createTransportedQueryRef<\n  TData,\n  TVariables extends OperationVariables,\n>(\n  query: DocumentNode | TypedDocumentNode<TData, TVariables>,\n  options: PreloadTransportedQueryOptions<TData, NoInfer<TVariables>>,\n  queryKey: string,\n  stream: ReadableStream<ReadableStreamLinkEvent>\n): TransportedQueryRef<TData, TVariables> {\n  return {\n    $__apollo_queryRef: {\n      options: sanitizeForTransport(serializeOptions({ query, ...options })),\n      queryKey,\n      stream: stream.pipeThrough(new JSONEncodeStream()),\n    },\n  };\n}\n\n/** @public */\nexport function reviveTransportedQueryRef(\n  queryRef: TransportedQueryRef,\n  client: ApolloClient\n): asserts queryRef is TransportedQueryRef & ReturnType<typeof wrapQueryRef> {\n  if (unwrapQueryRef(queryRef)) return;\n  const {\n    $__apollo_queryRef: { options, stream },\n  } = queryRef;\n  const hydratedOptions = deserializeOptions(options);\n  const internalQueryRef = getInternalQueryRef(client, hydratedOptions, {\n    ...hydratedOptions,\n    fetchPolicy: \"network-only\",\n    context: skipDataTransport(\n      readFromReadableStream(stream.pipeThrough(new JSONDecodeStream()), {\n        ...hydratedOptions.context,\n        queryDeduplication: true,\n      })\n    ),\n  });\n  Object.assign(queryRef, wrapQueryRef(internalQueryRef));\n}\n\nfunction getInternalQueryRef(\n  client: ApolloClient,\n  userOptions: ApolloClient.WatchQueryOptions,\n  initialFetchOptions: ApolloClient.WatchQueryOptions\n) {\n  if (__DEV__) {\n    // this would be a bug in our code, `initialFetchOptions` should always be derived\n    // from `userOptions` and never change `nextFetchPolicy` or we would need additional\n    // logic to handle that case\n    invariant(\n      userOptions.nextFetchPolicy === initialFetchOptions.nextFetchPolicy,\n      \"Encountered an unexpected bug in @apollo/client-react-streaming. Please file an issue.\"\n    );\n  }\n  // create with `userOptions` so internals like `initialFetchPolicy` are set correctly\n  const observable = client.watchQuery(userOptions);\n  // this might have filled in some defaults, so we need to capture them\n  const optionsAfterCreation = {\n    // context might still be `undefined`, so we need to make sure the property is at least present\n    // `undefined` won't merge in as `applyOptions` uses `compact`, so we use an empty object instead\n    context: {},\n    ...observable.options,\n  };\n  // apply `initialFetchOptions` for the first fetch\n  observable.applyOptions(initialFetchOptions);\n  // `new InternalQueryReference` calls `observable.subscribe` immediately, so the `initialFetchOptions` are applied to that call\n  const internalQueryRef = new InternalQueryReference(observable, {\n    autoDisposeTimeoutMs:\n      client.defaultOptions.react?.suspense?.autoDisposeTimeoutMs,\n  });\n  // set the options for any future `reobserve` calls back to `userOptions` directly after that\n  observable.applyOptions({\n    ...optionsAfterCreation,\n    fetchPolicy:\n      observable.options.fetchPolicy === initialFetchOptions.fetchPolicy\n        ? // restore `userOptions.fetchPolicy` for future fetches\n          optionsAfterCreation.fetchPolicy\n        : // otherwise `fetchPolicy` was changed from `initialFetchOptions`, `nextFetchPolicy` has been applied and we're not going to touch it\n          observable.options.fetchPolicy,\n  });\n  return internalQueryRef;\n}\n\n/** @public */\nexport function isTransportedQueryRef(\n  queryRef: any\n): queryRef is TransportedQueryRef {\n  return !!(queryRef && queryRef.$__apollo_queryRef);\n}\n\n/** @public */\n// This hook is injected into `useReadQuery` and `useQueryRefHandlers` to ensure that\n// `TransportedQueryRef`s are properly revived into `WrappedQueryRef`s before usage,\n// should they not be hydrated properly for some reason.\nexport function useWrapTransportedQueryRef<TData>(\n  queryRef:\n    | QueryRef<TData, any, \"complete\" | \"streaming\" | \"empty\" | \"partial\">\n    | TransportedQueryRef\n): QueryRef<TData> {\n  const client = useApolloClient();\n  const isTransported = isTransportedQueryRef(queryRef);\n  if (isTransported) {\n    reviveTransportedQueryRef(queryRef, client);\n  }\n  const unwrapped = unwrapQueryRef(queryRef)!;\n\n  // Soft-retaining because useQueryRefHandlers doesn't do it for us.\n  useEffect(() => {\n    if (isTransported) {\n      return unwrapped.softRetain();\n    }\n  }, [isTransported, unwrapped]);\n  return queryRef satisfies QueryRef<any, any, any> as QueryRef<TData>;\n}\n\nfunction sanitizeForTransport<T>(value: T) {\n  return JSON.parse(JSON.stringify(value)) as T;\n}\n\nfunction unmask(query: DocumentNode): DocumentNode {\n  return visit(query, {\n    FragmentSpread(node) {\n      return {\n        ...node,\n        directives: (node.directives || []).concat({\n          kind: Kind.DIRECTIVE,\n          name: { kind: Kind.NAME, value: \"unmask\" },\n        }),\n      };\n    },\n  });\n}\n","import { ApolloLink, Observable } from \"@apollo/client\";\n\n/**\n * @internal\n */\nexport type ReadableStreamLinkEvent =\n  | { type: \"next\"; value: ApolloLink.Result }\n  | { type: \"completed\" }\n  | { type: \"error\" };\n\n/**\n * Called when the link is hit, before the request is forwarded.\n *\n * Should return the controller for the readable stream.\n *\n * This is useful because when starting a query, it's not always\n * clear if the query will hit the network or will be served from\n * cache, deduplicated etc.\n * This allows to inject the \"start event\" into the stream only\n * when we know that more chunks will actually follow.\n */\ntype OnLinkHitFunction =\n  () => ReadableStreamDefaultController<ReadableStreamLinkEvent>;\ninterface InternalContext {\n  [teeToReadableStreamKey]?: OnLinkHitFunction;\n  [readFromReadableStreamKey]?: ReadableStream<ReadableStreamLinkEvent>;\n}\n\nconst teeToReadableStreamKey = Symbol.for(\n  \"apollo.tee.readableStreamController\"\n);\nconst readFromReadableStreamKey = Symbol.for(\"apollo.read.readableStream\");\n\n/**\n * Apply to a context that will be passed to a link chain containing `TeeToReadableStreamLink`.\n * @public\n */\nexport function teeToReadableStream<T extends Record<string, any>>(\n  onLinkHit: OnLinkHitFunction,\n  context: T\n): T & InternalContext {\n  return Object.assign(context, {\n    [teeToReadableStreamKey]: onLinkHit,\n  });\n}\n\n/**\n * Apply to a context that will be passed to a link chain containing `ReadFromReadableStreamLink`.\n * @public\n */\nexport function readFromReadableStream<T extends Record<string, any>>(\n  readableStream: ReadableStream<ReadableStreamLinkEvent>,\n  context: T\n): T & InternalContext {\n  return Object.assign(context, {\n    [readFromReadableStreamKey]: readableStream,\n  });\n}\n\n/**\n * A link that allows the request to be cloned into a readable stream, e.g. for\n * transport of multipart responses from RSC or a server loader to the browser.\n * @public\n */\nexport class TeeToReadableStreamLink extends ApolloLink {\n  constructor() {\n    super((operation, forward) => {\n      const context = operation.getContext() as InternalContext;\n\n      const onLinkHit = context[teeToReadableStreamKey];\n\n      if (onLinkHit) {\n        const controller = onLinkHit();\n\n        const tryClose = () => {\n          try {\n            controller.close();\n          } catch {\n            // maybe we already tried to close the stream, nothing to worry about\n          }\n        };\n        return new Observable((observer) => {\n          let subscribed = true;\n          forward(operation).subscribe({\n            next(result) {\n              controller.enqueue({ type: \"next\", value: result });\n              if (subscribed) {\n                observer.next(result);\n              }\n            },\n            error(error) {\n              controller.enqueue({ type: \"error\" });\n              tryClose();\n              if (subscribed) {\n                observer.error(error);\n              }\n            },\n            complete() {\n              controller.enqueue({ type: \"completed\" });\n              tryClose();\n              if (subscribed) {\n                observer.complete();\n              }\n            },\n          });\n\n          return () => {\n            subscribed = false;\n          };\n        });\n      }\n\n      return forward(operation);\n    });\n  }\n}\n\n/**\n * A link that allows the response to be read from a readable stream, e.g. for\n * hydration of a multipart response from RSC or a server loader in the browser.\n * @public\n */\nexport class ReadFromReadableStreamLink extends ApolloLink {\n  constructor() {\n    super((operation, forward) => {\n      const context = operation.getContext() as InternalContext;\n\n      const eventSteam = context[readFromReadableStreamKey];\n      if (eventSteam) {\n        return new Observable((observer) => {\n          let aborted = false as boolean;\n          const reader = (() => {\n            try {\n              return eventSteam.getReader();\n            } catch {\n              /**\n               * The reader could not be created, usually because the stream has\n               * already been consumed.\n               * This would be the case if we call `refetch` on a queryRef that has\n               * the `readFromReadableStreamKey` property in context.\n               * In that case, we want to do a normal network request.\n               */\n            }\n          })();\n\n          if (!reader) {\n            // if we can't create a reader, we want to do a normal network request\n            const subscription = forward(operation).subscribe(observer);\n            return () => subscription.unsubscribe();\n          }\n          let forwarded = false;\n          consume(reader).finally(() => {\n            // in case the stream ends without a `completed` event we still need to close the observer\n            // to avoid an the observable never being removed from `inFlightLinkObservables`\n            if (!observer.closed && !forwarded) {\n              observer.complete();\n            }\n          });\n          let onAbort = () => {\n            aborted = true;\n            reader.cancel();\n          };\n\n          return () => onAbort();\n\n          async function consume(\n            reader: ReadableStreamDefaultReader<ReadableStreamLinkEvent>\n          ) {\n            let event:\n              | ReadableStreamReadResult<ReadableStreamLinkEvent>\n              | undefined = undefined;\n            while (!aborted && !event?.done) {\n              event = await reader.read();\n              if (aborted) break;\n              if (event.value) {\n                switch (event.value.type) {\n                  case \"next\":\n                    observer.next(event.value.value);\n                    break;\n                  case \"completed\":\n                    observer.complete();\n                    break;\n                  case \"error\":\n                    // in case a network error happened on the sending side,\n                    if (process.env.REACT_ENV === \"ssr\") {\n                      // we want to fail SSR for this tree\n                      observer.error(\n                        new Error(\n                          \"Error from event stream. Redacted for security concerns.\"\n                        )\n                      );\n                    } else {\n                      // we want to retry the operation on the receiving side\n                      onAbort();\n                      forwarded = true;\n                      const subscription =\n                        forward(operation).subscribe(observer);\n                      onAbort = () => subscription.unsubscribe();\n                    }\n                    break;\n                }\n              }\n            }\n          }\n        });\n      }\n\n      return forward(operation);\n    });\n  }\n}\n","import { gql } from \"@apollo/client\";\nimport type { DocumentNode, FetchPolicy, ApolloClient } from \"@apollo/client\";\nimport { print } from \"@apollo/client/utilities\";\nimport { invariant } from \"@apollo/client/utilities/invariant\";\nimport { stripIgnoredCharacters } from \"graphql\";\n\nexport type TransportedOptions = {\n  query: string;\n  nextFetchPolicy?: FetchPolicy | undefined;\n} & Omit<\n  ApolloClient.WatchQueryOptions,\n  \"query\" | \"skipPollAttempt\" | \"nextFetchPolicy\"\n>;\n\nexport function serializeOptions<\n  T extends ApolloClient.WatchQueryOptions<any, any>,\n>(\n  options: T\n): { query: string; nextFetchPolicy?: FetchPolicy | undefined } & Omit<\n  T,\n  \"query\"\n> {\n  invariant(\n    typeof options.fetchPolicy !== \"function\",\n    \"`nextFetchPolicy` cannot be a function in server-client streaming\"\n  );\n  invariant(\n    typeof options.skipPollAttempt !== \"function\",\n    \"`skipPollAttempt` cannot be used with server-client streaming\"\n  );\n  return {\n    ...(options as typeof options & {\n      // little bit of a hack around the method signature, but the method signature would cause React to error anyways\n      nextFetchPolicy?: FetchPolicy | undefined;\n    }),\n    query: printMinified(options.query),\n  };\n}\n\nexport function deserializeOptions(\n  options: TransportedOptions\n): ApolloClient.WatchQueryOptions {\n  return {\n    ...options,\n    // `gql` memoizes results, but based on the input string.\n    // We parse-stringify-parse here to ensure that our minified query\n    // has the best chance of being the referential same query as the one used in\n    // client-side code.\n    query: gql(print(gql(options.query))),\n  };\n}\n\nfunction printMinified(query: DocumentNode): string {\n  return stripIgnoredCharacters(print(query));\n}\n","import type { HookWrappers } from \"@apollo/client/react/internal\";\nimport { useTransportValue } from \"./useTransportValue.js\";\nimport { useWrapTransportedQueryRef } from \"../transportedQueryRef.js\";\nimport { useMemo } from \"react\";\nimport { NetworkStatus } from \"@apollo/client\";\n\nexport const hookWrappers: HookWrappers = {\n  useFragment(orig_useFragment) {\n    return wrap(orig_useFragment, [\"data\", \"complete\", \"missing\", \"dataState\"]);\n  },\n  useQuery(orig_useQuery) {\n    return wrap<typeof orig_useQuery>(\n      process.env.REACT_ENV === \"ssr\"\n        ? (query, options) => {\n            const ret = orig_useQuery(\n              query,\n              typeof options === \"symbol\"\n                ? options\n                : {\n                    ...options,\n                    fetchPolicy: \"cache-only\",\n                  }\n            );\n\n            return typeof options === \"symbol\"\n              ? ret\n              : // if we changed the options to `cache-only` from something else,\n                options?.fetchPolicy !== \"cache-only\" &&\n                  // the value is not in the cache,\n                  ret.dataState === \"empty\" &&\n                  // and the query hasn't been skipped,\n                  ret.observable.options.fetchPolicy === \"cache-only\"\n                ? // we override the loading state to `true`\n                  {\n                    ...ret,\n                    loading: true,\n                    networkStatus: NetworkStatus.loading,\n                  }\n                : ret;\n          }\n        : orig_useQuery,\n      [\"data\", \"loading\", \"networkStatus\", \"dataState\"]\n    );\n  },\n  useSuspenseQuery(orig_useSuspenseQuery) {\n    return wrap(orig_useSuspenseQuery, [\"data\", \"networkStatus\", \"dataState\"]);\n  },\n  useReadQuery(orig_useReadQuery) {\n    return wrap(\n      (queryRef) => {\n        // eslint-disable-next-line react-hooks/rules-of-hooks\n        return orig_useReadQuery(useWrapTransportedQueryRef(queryRef));\n      },\n      [\"data\", \"networkStatus\", \"dataState\"]\n    );\n  },\n  useQueryRefHandlers(orig_useQueryRefHandlers) {\n    return wrap((queryRef) => {\n      // eslint-disable-next-line react-hooks/rules-of-hooks\n      return orig_useQueryRefHandlers(useWrapTransportedQueryRef(queryRef));\n    }, []);\n  },\n  useSuspenseFragment(orig_useSuspenseFragment) {\n    return wrap(orig_useSuspenseFragment, [\"data\"]);\n  },\n};\n\nfunction wrap<T extends (...args: any[]) => any>(\n  useFn: T,\n  transportKeys: (keyof ReturnType<T>)[]\n): T {\n  return ((...args: any[]) => {\n    const result = useFn(...args);\n    if (transportKeys.length == 0) {\n      return result;\n    }\n    const forTransport = useMemo<Partial<typeof result>>(() => {\n      const transport: Partial<typeof result> = {};\n      for (const key of transportKeys) {\n        transport[key] = result[key];\n      }\n      return transport;\n    }, [result]);\n    const transported = useTransportValue(forTransport);\n\n    return useMemo(\n      () => ({ ...result, ...transported }),\n      [result, transported]\n    );\n  }) as T;\n}\n","import type { bundle } from \"./bundleInfo.js\";\nimport { sourceSymbol } from \"./bundleInfo.js\";\n\nexport function assertInstance(\n  value: { [sourceSymbol]?: string },\n  info: typeof bundle,\n  name: string\n): void {\n  if (value[sourceSymbol] !== `${info.pkg}:${name}`) {\n    throw new Error(\n      `When using \\`${name}\\` in streaming SSR, you must use the \\`${name}\\` export provided by \\`\"${info.pkg}\"\\`.`\n    );\n  }\n}\n","export const ApolloClientSingleton = /*#__PURE__*/ Symbol.for(\n  \"ApolloClientSingleton\"\n);\n","import { ApolloClientSingleton } from \"./symbols.js\";\n\n/**\n * > This export is only available in React Client Components\n *\n * Resets the singleton instances created for the Apollo SSR data transport and caches.\n *\n * To be used in testing only, like\n * ```ts\n * afterEach(resetApolloSingletons);\n * ```\n *\n * @public\n */\nexport function resetApolloSingletons() {\n  delete window[ApolloClientSingleton];\n}\n","\"use client\";\nimport React from \"react\";\nimport { useRef } from \"react\";\nimport type { ApolloClient } from \"./WrappedApolloClient.js\";\nimport { ApolloProvider } from \"@apollo/client/react\";\nimport type { DataTransportProviderImplementation } from \"./DataTransportAbstraction.js\";\nimport { ApolloClientSingleton } from \"./symbols.js\";\nimport { bundle } from \"../bundleInfo.js\";\nimport { assertInstance } from \"../assertInstance.js\";\n\ndeclare global {\n  interface Window {\n    [ApolloClientSingleton]?: ApolloClient;\n  }\n}\n\n/**\n * > This is only available in React Client Components\n *\n * A version of `ApolloProvider` particularly suited for React's streaming SSR.\n *\n * @public\n */\nexport interface WrappedApolloProvider<ExtraProps> {\n  ({\n    makeClient,\n    children,\n    ...extraProps\n  }: React.PropsWithChildren<\n    {\n      makeClient: () => ApolloClient;\n    } & ExtraProps\n  >): React.JSX.Element;\n  /**\n   * Information about the current package and it's export names, for use in error messages.\n   */\n  info: {\n    pkg: string;\n  };\n}\n\n/**\n * > This export is only available in React Client Components\n *\n * Creates an ApolloProvider for streaming SSR.\n *\n * @param TransportProvider - The transport provider to be used.\n * This could e.g. be a `ManualDataTransport` created by `buildManualDataTransport`,\n * or a fully custom implementation of `DataTransportProviderImplementation`.\n * @public\n */\nexport function WrapApolloProvider<ExtraProps>(\n  TransportProvider: DataTransportProviderImplementation<ExtraProps>\n): WrappedApolloProvider<ExtraProps> {\n  const WrappedApolloProvider: WrappedApolloProvider<ExtraProps> = ({\n    makeClient,\n    children,\n    ...extraProps\n  }) => {\n    const clientRef = useRef<ApolloClient>(undefined);\n    if (!clientRef.current) {\n      if (process.env.REACT_ENV === \"ssr\") {\n        clientRef.current = makeClient();\n      } else {\n        clientRef.current = window[ApolloClientSingleton] ??= makeClient();\n      }\n      assertInstance(\n        clientRef.current,\n        WrappedApolloProvider.info,\n        \"ApolloClient\"\n      );\n    }\n\n    return (\n      <ApolloProvider client={clientRef.current}>\n        <TransportProvider\n          onQueryEvent={(event) =>\n            event.type === \"started\"\n              ? clientRef.current!.onQueryStarted!(event)\n              : clientRef.current!.onQueryProgress!(event)\n          }\n          rerunSimulatedQueries={clientRef.current.rerunSimulatedQueries}\n          registerDispatchRequestStarted={\n            clientRef.current.watchQueryQueue?.register\n          }\n          {...(extraProps as ExtraProps)}\n        >\n          {children}\n        </TransportProvider>\n      </ApolloProvider>\n    );\n  };\n  WrappedApolloProvider.info = bundle;\n  return WrappedApolloProvider;\n}\n"]}