@tanstack/react-query-next-experimental 5.0.0-alpha.80

package/build/lib/ReactQueryStreamedHydration.cjs

@@ -0,0 +1,89 @@
+'use client';
+'use strict';
+
+var reactQuery = require('@tanstack/react-query');
+var React = require('react');
+var HydrationStreamProvider = require('./HydrationStreamProvider.cjs');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
+
+const stream = HydrationStreamProvider.createHydrationStreamProvider();
+
+/**
+ * This component is responsible for:
+ * - hydrating the query client on the server
+ * - dehydrating the query client on the server
+ */
+function ReactQueryStreamedHydration(props) {
+  const queryClient = reactQuery.useQueryClient(props.queryClient);
+
+  /**
+   * We need to track which queries were added/updated during the render
+   */
+  const [trackedKeys] = React__namespace.useState(() => new Set());
+
+  // <server only>
+  if (typeof window === 'undefined') {
+    // Do we need to care about unsubscribing? I don't think so to be honest
+    queryClient.getQueryCache().subscribe(event => {
+      switch (event.type) {
+        case 'added':
+        case 'updated':
+          // console.log('tracking', event.query.queryHash, 'b/c of a', event.type)
+          trackedKeys.add(event.query.queryHash);
+      }
+    });
+  }
+  // </server only>
+
+  return /*#__PURE__*/React__namespace.createElement(stream.Provider, {
+    // Happens on server:
+    onFlush: () => {
+      /**
+       * Dehydrated state of the client where we only include the queries that were added/updated since the last flush
+       */
+      const shouldDehydrate = props.options?.dehydrate?.shouldDehydrateQuery ?? reactQuery.defaultShouldDehydrateQuery;
+      const dehydratedState = reactQuery.dehydrate(queryClient, {
+        ...props.options?.dehydrate,
+        shouldDehydrateQuery(query) {
+          return trackedKeys.has(query.queryHash) && shouldDehydrate(query);
+        }
+      });
+      trackedKeys.clear();
+      if (!dehydratedState.queries.length) {
+        return [];
+      }
+      return [dehydratedState];
+    }
+    // Happens in browser:
+    ,
+    onEntries: entries => {
+      for (const hydratedState of entries) {
+        reactQuery.hydrate(queryClient, hydratedState, props.options?.hydrate);
+      }
+    }
+    // Handle BigInts etc using superjson
+    ,
+    transformer: props.transformer
+  }, props.children);
+}
+
+exports.ReactQueryStreamedHydration = ReactQueryStreamedHydration;
+//# sourceMappingURL=ReactQueryStreamedHydration.cjs.map

package/build/lib/ReactQueryStreamedHydration.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReactQueryStreamedHydration.cjs","sources":["../../src/ReactQueryStreamedHydration.tsx"],"sourcesContent":["'use client'\n\nimport type {\n  DehydratedState,\n  DehydrateOptions,\n  HydrateOptions,\n  QueryClient,\n} from '@tanstack/react-query'\nimport {\n  defaultShouldDehydrateQuery,\n  dehydrate,\n  hydrate,\n  useQueryClient,\n} from '@tanstack/react-query'\nimport * as React from 'react'\nimport type { HydrationStreamProviderProps } from './HydrationStreamProvider'\nimport { createHydrationStreamProvider } from './HydrationStreamProvider'\n\nconst stream = createHydrationStreamProvider<DehydratedState>()\n\n/**\n * This component is responsible for:\n * - hydrating the query client on the server\n * - dehydrating the query client on the server\n */\nexport function ReactQueryStreamedHydration(props: {\n  children: React.ReactNode\n  queryClient?: QueryClient\n  options?: {\n    hydrate?: HydrateOptions\n    dehydrate?: DehydrateOptions\n  }\n  transformer?: HydrationStreamProviderProps<DehydratedState>['transformer']\n}) {\n  const queryClient = useQueryClient(props.queryClient)\n\n  /**\n   * We need to track which queries were added/updated during the render\n   */\n  const [trackedKeys] = React.useState(() => new Set<string>())\n\n  // <server only>\n  if (typeof window === 'undefined') {\n    // Do we need to care about unsubscribing? I don't think so to be honest\n    queryClient.getQueryCache().subscribe((event) => {\n      switch (event.type) {\n        case 'added':\n        case 'updated':\n          // console.log('tracking', event.query.queryHash, 'b/c of a', event.type)\n          trackedKeys.add(event.query.queryHash)\n      }\n    })\n  }\n  // </server only>\n\n  return (\n    <stream.Provider\n      // Happens on server:\n      onFlush={() => {\n        /**\n         * Dehydrated state of the client where we only include the queries that were added/updated since the last flush\n         */\n        const shouldDehydrate =\n          props.options?.dehydrate?.shouldDehydrateQuery ??\n          defaultShouldDehydrateQuery\n\n        const dehydratedState = dehydrate(queryClient, {\n          ...props.options?.dehydrate,\n          shouldDehydrateQuery(query) {\n            return trackedKeys.has(query.queryHash) && shouldDehydrate(query)\n          },\n        })\n        trackedKeys.clear()\n\n        if (!dehydratedState.queries.length) {\n          return []\n        }\n\n        return [dehydratedState]\n      }}\n      // Happens in browser:\n      onEntries={(entries) => {\n        for (const hydratedState of entries) {\n          hydrate(queryClient, hydratedState, props.options?.hydrate)\n        }\n      }}\n      // Handle BigInts etc using superjson\n      transformer={props.transformer}\n    >\n      {props.children}\n    </stream.Provider>\n  )\n}\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAkBA;;AAEA;AACA;AACA;AACA;AACA;AACO;AASL;;AAEA;AACF;AACA;AACE;;AAEA;AACA;AACE;;;AAGI;AACA;AACE;;AAEJ;AACF;AACF;AACA;;AAEA;AAEI;;AAEE;AACR;AACA;;AAKQ;AACE;;AAEE;AACF;AACF;;AAGA;AACE;AACF;;AAGF;AACA;AAAA;;AAEE;;AAEA;AACF;AACA;AAAA;;;AAMN;;"}

package/build/lib/ReactQueryStreamedHydration.d.ts

@@ -0,0 +1,18 @@
+import type { DehydratedState, DehydrateOptions, HydrateOptions, QueryClient } from '@tanstack/react-query';
+import * as React from 'react';
+import type { HydrationStreamProviderProps } from './HydrationStreamProvider';
+/**
+ * This component is responsible for:
+ * - hydrating the query client on the server
+ * - dehydrating the query client on the server
+ */
+export declare function ReactQueryStreamedHydration(props: {
+    children: React.ReactNode;
+    queryClient?: QueryClient;
+    options?: {
+        hydrate?: HydrateOptions;
+        dehydrate?: DehydrateOptions;
+    };
+    transformer?: HydrationStreamProviderProps<DehydratedState>['transformer'];
+}): React.JSX.Element;
+//# sourceMappingURL=ReactQueryStreamedHydration.d.ts.map

package/build/lib/ReactQueryStreamedHydration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReactQueryStreamedHydration.d.ts","sourceRoot":"","sources":["../../src/ReactQueryStreamedHydration.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,eAAe,EACf,gBAAgB,EAChB,cAAc,EACd,WAAW,EACZ,MAAM,uBAAuB,CAAA;AAO9B,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAC9B,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,2BAA2B,CAAA;AAK7E;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE;IACjD,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;IACzB,WAAW,CAAC,EAAE,WAAW,CAAA;IACzB,OAAO,CAAC,EAAE;QACR,OAAO,CAAC,EAAE,cAAc,CAAA;QACxB,SAAS,CAAC,EAAE,gBAAgB,CAAA;KAC7B,CAAA;IACD,WAAW,CAAC,EAAE,4BAA4B,CAAC,eAAe,CAAC,CAAC,aAAa,CAAC,CAAA;CAC3E,qBA2DA"}

package/build/lib/ReactQueryStreamedHydration.js

@@ -0,0 +1,68 @@
+'use client';
+import { useQueryClient, defaultShouldDehydrateQuery, dehydrate, hydrate } from '@tanstack/react-query';
+import * as React from 'react';
+import { createHydrationStreamProvider } from './HydrationStreamProvider.js';
+
+const stream = createHydrationStreamProvider();
+
+/**
+ * This component is responsible for:
+ * - hydrating the query client on the server
+ * - dehydrating the query client on the server
+ */
+function ReactQueryStreamedHydration(props) {
+  const queryClient = useQueryClient(props.queryClient);
+
+  /**
+   * We need to track which queries were added/updated during the render
+   */
+  const [trackedKeys] = React.useState(() => new Set());
+
+  // <server only>
+  if (typeof window === 'undefined') {
+    // Do we need to care about unsubscribing? I don't think so to be honest
+    queryClient.getQueryCache().subscribe(event => {
+      switch (event.type) {
+        case 'added':
+        case 'updated':
+          // console.log('tracking', event.query.queryHash, 'b/c of a', event.type)
+          trackedKeys.add(event.query.queryHash);
+      }
+    });
+  }
+  // </server only>
+
+  return /*#__PURE__*/React.createElement(stream.Provider, {
+    // Happens on server:
+    onFlush: () => {
+      /**
+       * Dehydrated state of the client where we only include the queries that were added/updated since the last flush
+       */
+      const shouldDehydrate = props.options?.dehydrate?.shouldDehydrateQuery ?? defaultShouldDehydrateQuery;
+      const dehydratedState = dehydrate(queryClient, {
+        ...props.options?.dehydrate,
+        shouldDehydrateQuery(query) {
+          return trackedKeys.has(query.queryHash) && shouldDehydrate(query);
+        }
+      });
+      trackedKeys.clear();
+      if (!dehydratedState.queries.length) {
+        return [];
+      }
+      return [dehydratedState];
+    }
+    // Happens in browser:
+    ,
+    onEntries: entries => {
+      for (const hydratedState of entries) {
+        hydrate(queryClient, hydratedState, props.options?.hydrate);
+      }
+    }
+    // Handle BigInts etc using superjson
+    ,
+    transformer: props.transformer
+  }, props.children);
+}
+
+export { ReactQueryStreamedHydration };
+//# sourceMappingURL=ReactQueryStreamedHydration.js.map

package/build/lib/ReactQueryStreamedHydration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReactQueryStreamedHydration.js","sources":["../../src/ReactQueryStreamedHydration.tsx"],"sourcesContent":["'use client'\n\nimport type {\n  DehydratedState,\n  DehydrateOptions,\n  HydrateOptions,\n  QueryClient,\n} from '@tanstack/react-query'\nimport {\n  defaultShouldDehydrateQuery,\n  dehydrate,\n  hydrate,\n  useQueryClient,\n} from '@tanstack/react-query'\nimport * as React from 'react'\nimport type { HydrationStreamProviderProps } from './HydrationStreamProvider'\nimport { createHydrationStreamProvider } from './HydrationStreamProvider'\n\nconst stream = createHydrationStreamProvider<DehydratedState>()\n\n/**\n * This component is responsible for:\n * - hydrating the query client on the server\n * - dehydrating the query client on the server\n */\nexport function ReactQueryStreamedHydration(props: {\n  children: React.ReactNode\n  queryClient?: QueryClient\n  options?: {\n    hydrate?: HydrateOptions\n    dehydrate?: DehydrateOptions\n  }\n  transformer?: HydrationStreamProviderProps<DehydratedState>['transformer']\n}) {\n  const queryClient = useQueryClient(props.queryClient)\n\n  /**\n   * We need to track which queries were added/updated during the render\n   */\n  const [trackedKeys] = React.useState(() => new Set<string>())\n\n  // <server only>\n  if (typeof window === 'undefined') {\n    // Do we need to care about unsubscribing? I don't think so to be honest\n    queryClient.getQueryCache().subscribe((event) => {\n      switch (event.type) {\n        case 'added':\n        case 'updated':\n          // console.log('tracking', event.query.queryHash, 'b/c of a', event.type)\n          trackedKeys.add(event.query.queryHash)\n      }\n    })\n  }\n  // </server only>\n\n  return (\n    <stream.Provider\n      // Happens on server:\n      onFlush={() => {\n        /**\n         * Dehydrated state of the client where we only include the queries that were added/updated since the last flush\n         */\n        const shouldDehydrate =\n          props.options?.dehydrate?.shouldDehydrateQuery ??\n          defaultShouldDehydrateQuery\n\n        const dehydratedState = dehydrate(queryClient, {\n          ...props.options?.dehydrate,\n          shouldDehydrateQuery(query) {\n            return trackedKeys.has(query.queryHash) && shouldDehydrate(query)\n          },\n        })\n        trackedKeys.clear()\n\n        if (!dehydratedState.queries.length) {\n          return []\n        }\n\n        return [dehydratedState]\n      }}\n      // Happens in browser:\n      onEntries={(entries) => {\n        for (const hydratedState of entries) {\n          hydrate(queryClient, hydratedState, props.options?.hydrate)\n        }\n      }}\n      // Handle BigInts etc using superjson\n      transformer={props.transformer}\n    >\n      {props.children}\n    </stream.Provider>\n  )\n}\n"],"names":[],"mappings":";;;;;AAkBA;;AAEA;AACA;AACA;AACA;AACA;AACO;AASL;;AAEA;AACF;AACA;AACE;;AAEA;AACA;AACE;;;AAGI;AACA;AACE;;AAEJ;AACF;AACF;AACA;;AAEA;AAEI;;AAEE;AACR;AACA;;AAKQ;AACE;;AAEE;AACF;AACF;;AAGA;AACE;AACF;;AAGF;AACA;AAAA;;AAEE;;AAEA;AACF;AACA;AAAA;;;AAMN;;"}

package/build/lib/ReactQueryStreamedHydration.legacy.cjs

@@ -0,0 +1,91 @@
+'use client';
+'use strict';
+
+var reactQuery = require('@tanstack/react-query');
+var React = require('react');
+var HydrationStreamProvider = require('./HydrationStreamProvider.legacy.cjs');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
+
+const stream = HydrationStreamProvider.createHydrationStreamProvider();
+
+/**
+ * This component is responsible for:
+ * - hydrating the query client on the server
+ * - dehydrating the query client on the server
+ */
+function ReactQueryStreamedHydration(props) {
+  const queryClient = reactQuery.useQueryClient(props.queryClient);
+
+  /**
+   * We need to track which queries were added/updated during the render
+   */
+  const [trackedKeys] = React__namespace.useState(() => new Set());
+
+  // <server only>
+  if (typeof window === 'undefined') {
+    // Do we need to care about unsubscribing? I don't think so to be honest
+    queryClient.getQueryCache().subscribe(event => {
+      switch (event.type) {
+        case 'added':
+        case 'updated':
+          // console.log('tracking', event.query.queryHash, 'b/c of a', event.type)
+          trackedKeys.add(event.query.queryHash);
+      }
+    });
+  }
+  // </server only>
+
+  return /*#__PURE__*/React__namespace.createElement(stream.Provider, {
+    // Happens on server:
+    onFlush: () => {
+      var _props$options$dehydr, _props$options, _props$options$dehydr2, _props$options2;
+      /**
+       * Dehydrated state of the client where we only include the queries that were added/updated since the last flush
+       */
+      const shouldDehydrate = (_props$options$dehydr = (_props$options = props.options) == null ? void 0 : (_props$options$dehydr2 = _props$options.dehydrate) == null ? void 0 : _props$options$dehydr2.shouldDehydrateQuery) != null ? _props$options$dehydr : reactQuery.defaultShouldDehydrateQuery;
+      const dehydratedState = reactQuery.dehydrate(queryClient, {
+        ...((_props$options2 = props.options) == null ? void 0 : _props$options2.dehydrate),
+        shouldDehydrateQuery(query) {
+          return trackedKeys.has(query.queryHash) && shouldDehydrate(query);
+        }
+      });
+      trackedKeys.clear();
+      if (!dehydratedState.queries.length) {
+        return [];
+      }
+      return [dehydratedState];
+    }
+    // Happens in browser:
+    ,
+    onEntries: entries => {
+      for (const hydratedState of entries) {
+        var _props$options3;
+        reactQuery.hydrate(queryClient, hydratedState, (_props$options3 = props.options) == null ? void 0 : _props$options3.hydrate);
+      }
+    }
+    // Handle BigInts etc using superjson
+    ,
+    transformer: props.transformer
+  }, props.children);
+}
+
+exports.ReactQueryStreamedHydration = ReactQueryStreamedHydration;
+//# sourceMappingURL=ReactQueryStreamedHydration.legacy.cjs.map

package/build/lib/ReactQueryStreamedHydration.legacy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReactQueryStreamedHydration.legacy.cjs","sources":["../../src/ReactQueryStreamedHydration.tsx"],"sourcesContent":["'use client'\n\nimport type {\n  DehydratedState,\n  DehydrateOptions,\n  HydrateOptions,\n  QueryClient,\n} from '@tanstack/react-query'\nimport {\n  defaultShouldDehydrateQuery,\n  dehydrate,\n  hydrate,\n  useQueryClient,\n} from '@tanstack/react-query'\nimport * as React from 'react'\nimport type { HydrationStreamProviderProps } from './HydrationStreamProvider'\nimport { createHydrationStreamProvider } from './HydrationStreamProvider'\n\nconst stream = createHydrationStreamProvider<DehydratedState>()\n\n/**\n * This component is responsible for:\n * - hydrating the query client on the server\n * - dehydrating the query client on the server\n */\nexport function ReactQueryStreamedHydration(props: {\n  children: React.ReactNode\n  queryClient?: QueryClient\n  options?: {\n    hydrate?: HydrateOptions\n    dehydrate?: DehydrateOptions\n  }\n  transformer?: HydrationStreamProviderProps<DehydratedState>['transformer']\n}) {\n  const queryClient = useQueryClient(props.queryClient)\n\n  /**\n   * We need to track which queries were added/updated during the render\n   */\n  const [trackedKeys] = React.useState(() => new Set<string>())\n\n  // <server only>\n  if (typeof window === 'undefined') {\n    // Do we need to care about unsubscribing? I don't think so to be honest\n    queryClient.getQueryCache().subscribe((event) => {\n      switch (event.type) {\n        case 'added':\n        case 'updated':\n          // console.log('tracking', event.query.queryHash, 'b/c of a', event.type)\n          trackedKeys.add(event.query.queryHash)\n      }\n    })\n  }\n  // </server only>\n\n  return (\n    <stream.Provider\n      // Happens on server:\n      onFlush={() => {\n        /**\n         * Dehydrated state of the client where we only include the queries that were added/updated since the last flush\n         */\n        const shouldDehydrate =\n          props.options?.dehydrate?.shouldDehydrateQuery ??\n          defaultShouldDehydrateQuery\n\n        const dehydratedState = dehydrate(queryClient, {\n          ...props.options?.dehydrate,\n          shouldDehydrateQuery(query) {\n            return trackedKeys.has(query.queryHash) && shouldDehydrate(query)\n          },\n        })\n        trackedKeys.clear()\n\n        if (!dehydratedState.queries.length) {\n          return []\n        }\n\n        return [dehydratedState]\n      }}\n      // Happens in browser:\n      onEntries={(entries) => {\n        for (const hydratedState of entries) {\n          hydrate(queryClient, hydratedState, props.options?.hydrate)\n        }\n      }}\n      // Handle BigInts etc using superjson\n      transformer={props.transformer}\n    >\n      {props.children}\n    </stream.Provider>\n  )\n}\n"],"names":["hydrate"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAkBA;;AAEA;AACA;AACA;AACA;AACA;AACO;AASL;;AAEA;AACF;AACA;AACE;;AAEA;AACA;AACE;;;AAGI;AACA;AACE;;AAEJ;AACF;AACF;AACA;;AAEA;AAEI;;AACe;AACb;AACR;AACA;;AAKQ;;;AAGI;AACF;AACF;;AAGA;AACE;AACF;;AAGF;AACA;AAAA;;AAEE;AAAqC;AACnCA;AACF;AACF;AACA;AAAA;;;AAMN;;"}

package/build/lib/ReactQueryStreamedHydration.legacy.js

@@ -0,0 +1,70 @@
+'use client';
+import { useQueryClient, defaultShouldDehydrateQuery, dehydrate, hydrate } from '@tanstack/react-query';
+import * as React from 'react';
+import { createHydrationStreamProvider } from './HydrationStreamProvider.legacy.js';
+
+const stream = createHydrationStreamProvider();
+
+/**
+ * This component is responsible for:
+ * - hydrating the query client on the server
+ * - dehydrating the query client on the server
+ */
+function ReactQueryStreamedHydration(props) {
+  const queryClient = useQueryClient(props.queryClient);
+
+  /**
+   * We need to track which queries were added/updated during the render
+   */
+  const [trackedKeys] = React.useState(() => new Set());
+
+  // <server only>
+  if (typeof window === 'undefined') {
+    // Do we need to care about unsubscribing? I don't think so to be honest
+    queryClient.getQueryCache().subscribe(event => {
+      switch (event.type) {
+        case 'added':
+        case 'updated':
+          // console.log('tracking', event.query.queryHash, 'b/c of a', event.type)
+          trackedKeys.add(event.query.queryHash);
+      }
+    });
+  }
+  // </server only>
+
+  return /*#__PURE__*/React.createElement(stream.Provider, {
+    // Happens on server:
+    onFlush: () => {
+      var _props$options$dehydr, _props$options, _props$options$dehydr2, _props$options2;
+      /**
+       * Dehydrated state of the client where we only include the queries that were added/updated since the last flush
+       */
+      const shouldDehydrate = (_props$options$dehydr = (_props$options = props.options) == null ? void 0 : (_props$options$dehydr2 = _props$options.dehydrate) == null ? void 0 : _props$options$dehydr2.shouldDehydrateQuery) != null ? _props$options$dehydr : defaultShouldDehydrateQuery;
+      const dehydratedState = dehydrate(queryClient, {
+        ...((_props$options2 = props.options) == null ? void 0 : _props$options2.dehydrate),
+        shouldDehydrateQuery(query) {
+          return trackedKeys.has(query.queryHash) && shouldDehydrate(query);
+        }
+      });
+      trackedKeys.clear();
+      if (!dehydratedState.queries.length) {
+        return [];
+      }
+      return [dehydratedState];
+    }
+    // Happens in browser:
+    ,
+    onEntries: entries => {
+      for (const hydratedState of entries) {
+        var _props$options3;
+        hydrate(queryClient, hydratedState, (_props$options3 = props.options) == null ? void 0 : _props$options3.hydrate);
+      }
+    }
+    // Handle BigInts etc using superjson
+    ,
+    transformer: props.transformer
+  }, props.children);
+}
+
+export { ReactQueryStreamedHydration };
+//# sourceMappingURL=ReactQueryStreamedHydration.legacy.js.map

package/build/lib/ReactQueryStreamedHydration.legacy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReactQueryStreamedHydration.legacy.js","sources":["../../src/ReactQueryStreamedHydration.tsx"],"sourcesContent":["'use client'\n\nimport type {\n  DehydratedState,\n  DehydrateOptions,\n  HydrateOptions,\n  QueryClient,\n} from '@tanstack/react-query'\nimport {\n  defaultShouldDehydrateQuery,\n  dehydrate,\n  hydrate,\n  useQueryClient,\n} from '@tanstack/react-query'\nimport * as React from 'react'\nimport type { HydrationStreamProviderProps } from './HydrationStreamProvider'\nimport { createHydrationStreamProvider } from './HydrationStreamProvider'\n\nconst stream = createHydrationStreamProvider<DehydratedState>()\n\n/**\n * This component is responsible for:\n * - hydrating the query client on the server\n * - dehydrating the query client on the server\n */\nexport function ReactQueryStreamedHydration(props: {\n  children: React.ReactNode\n  queryClient?: QueryClient\n  options?: {\n    hydrate?: HydrateOptions\n    dehydrate?: DehydrateOptions\n  }\n  transformer?: HydrationStreamProviderProps<DehydratedState>['transformer']\n}) {\n  const queryClient = useQueryClient(props.queryClient)\n\n  /**\n   * We need to track which queries were added/updated during the render\n   */\n  const [trackedKeys] = React.useState(() => new Set<string>())\n\n  // <server only>\n  if (typeof window === 'undefined') {\n    // Do we need to care about unsubscribing? I don't think so to be honest\n    queryClient.getQueryCache().subscribe((event) => {\n      switch (event.type) {\n        case 'added':\n        case 'updated':\n          // console.log('tracking', event.query.queryHash, 'b/c of a', event.type)\n          trackedKeys.add(event.query.queryHash)\n      }\n    })\n  }\n  // </server only>\n\n  return (\n    <stream.Provider\n      // Happens on server:\n      onFlush={() => {\n        /**\n         * Dehydrated state of the client where we only include the queries that were added/updated since the last flush\n         */\n        const shouldDehydrate =\n          props.options?.dehydrate?.shouldDehydrateQuery ??\n          defaultShouldDehydrateQuery\n\n        const dehydratedState = dehydrate(queryClient, {\n          ...props.options?.dehydrate,\n          shouldDehydrateQuery(query) {\n            return trackedKeys.has(query.queryHash) && shouldDehydrate(query)\n          },\n        })\n        trackedKeys.clear()\n\n        if (!dehydratedState.queries.length) {\n          return []\n        }\n\n        return [dehydratedState]\n      }}\n      // Happens in browser:\n      onEntries={(entries) => {\n        for (const hydratedState of entries) {\n          hydrate(queryClient, hydratedState, props.options?.hydrate)\n        }\n      }}\n      // Handle BigInts etc using superjson\n      transformer={props.transformer}\n    >\n      {props.children}\n    </stream.Provider>\n  )\n}\n"],"names":["hydrate"],"mappings":";;;;;AAkBA;;AAEA;AACA;AACA;AACA;AACA;AACO;AASL;;AAEA;AACF;AACA;AACE;;AAEA;AACA;AACE;;;AAGI;AACA;AACE;;AAEJ;AACF;AACF;AACA;;AAEA;AAEI;;AACe;AACb;AACR;AACA;;AAKQ;;;AAGI;AACF;AACF;;AAGA;AACE;AACF;;AAGF;AACA;AAAA;;AAEE;AAAqC;AACnCA;AACF;AACF;AACA;AAAA;;;AAMN;;"}

package/build/lib/index.cjs

@@ -0,0 +1,8 @@
+'use strict';
+
+var ReactQueryStreamedHydration = require('./ReactQueryStreamedHydration.cjs');
+
+
+
+exports.ReactQueryStreamedHydration = ReactQueryStreamedHydration.ReactQueryStreamedHydration;
+//# sourceMappingURL=index.cjs.map

package/build/lib/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;"}

package/build/lib/index.d.ts

@@ -0,0 +1,2 @@
+export { ReactQueryStreamedHydration } from './ReactQueryStreamedHydration';
+//# sourceMappingURL=index.d.ts.map

package/build/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAA"}

package/build/lib/index.js

@@ -0,0 +1,2 @@
+export { ReactQueryStreamedHydration } from './ReactQueryStreamedHydration.js';
+//# sourceMappingURL=index.js.map

package/build/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/build/lib/index.legacy.cjs

@@ -0,0 +1,8 @@
+'use strict';
+
+var ReactQueryStreamedHydration = require('./ReactQueryStreamedHydration.legacy.cjs');
+
+
+
+exports.ReactQueryStreamedHydration = ReactQueryStreamedHydration.ReactQueryStreamedHydration;
+//# sourceMappingURL=index.legacy.cjs.map

package/build/lib/index.legacy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.legacy.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;"}

package/build/lib/index.legacy.js

@@ -0,0 +1,2 @@
+export { ReactQueryStreamedHydration } from './ReactQueryStreamedHydration.legacy.js';
+//# sourceMappingURL=index.legacy.js.map

package/build/lib/index.legacy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.legacy.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@tanstack/react-query-next-experimental",
+  "version": "5.0.0-alpha.80",
+  "description": "Hydration utils for React Query in the NextJs app directory",
+  "author": "tannerlinsley",
+  "license": "MIT",
+  "repository": "tanstack/query",
+  "homepage": "https://tanstack.com/query",
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/tannerlinsley"
+  },
+  "type": "module",
+  "types": "build/lib/index.d.ts",
+  "main": "build/lib/index.legacy.cjs",
+  "module": "build/lib/index.legacy.js",
+  "exports": {
+    ".": {
+      "types": "./build/lib/index.d.ts",
+      "import": "./build/lib/index.js",
+      "require": "./build/lib/index.cjs",
+      "default": "./build/lib/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "sideEffects": false,
+  "files": [
+    "build/lib/*",
+    "src"
+  ],
+  "devDependencies": {
+    "@types/react": "^18.2.4",
+    "@types/react-dom": "^18.2.4",
+    "next": "^13.4.6",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "react-error-boundary": "^3.1.4",
+    "@tanstack/react-query": "5.0.0-alpha.71"
+  },
+  "peerDependencies": {
+    "next": "^13.0.0",
+    "react": "^18.0.0",
+    "react-dom": "^18.0.0",
+    "@tanstack/react-query": "5.0.0-alpha.71"
+  },
+  "scripts": {
+    "clean": "rimraf ./build && rimraf ./coverage",
+    "test:eslint": "eslint --ext .ts,.tsx ./src",
+    "test:types": "tsc --noEmit",
+    "test:lib": "vitest run --coverage --passWithNoTests",
+    "test:lib:dev": "pnpm run test:lib --watch",
+    "test:build": "publint --strict",
+    "build": "pnpm build:rollup && pnpm build:types",
+    "build:rollup": "rollup --config rollup.config.js",
+    "build:types": "tsc --emitDeclarationOnly"
+  }
+}