houdini-react 1.2.25 → 1.2.27

package/build/runtime-cjs/server/renderToStream/createPipeWrapper.js

@@ -0,0 +1,90 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var createPipeWrapper_exports = {};
+__export(createPipeWrapper_exports, {
+  createPipeWrapper: () => createPipeWrapper
+});
+module.exports = __toCommonJS(createPipeWrapper_exports);
+var import_utils = require("../utils");
+var import_createBuffer = require("./createBuffer");
+var import_loadNodeStreamModule = require("./loadNodeStreamModule");
+const debug = (0, import_utils.createDebugger)("react-streaming:createPipeWrapper");
+async function createPipeWrapper(pipeFromReact, { onReactBug }) {
+  const { Writable } = await (0, import_loadNodeStreamModule.loadNodeStreamModule)();
+  const { pipeForUser, streamEnd } = createPipeForUser();
+  const streamOperations = {
+    operations: null
+  };
+  const { injectToStream, onBeforeWrite, onBeforeEnd } = (0, import_createBuffer.createBuffer)(streamOperations);
+  return { pipeForUser, streamEnd, injectToStream };
+  function createPipeForUser() {
+    debug("createPipeForUser()");
+    let onEnded;
+    const streamEnd2 = new Promise((r) => {
+      onEnded = () => r();
+    });
+    const pipeForUser2 = (writableFromUser) => {
+      const writableForReact = new Writable({
+        write(chunk, encoding, callback) {
+          debug("write");
+          onBeforeWrite(chunk);
+          if (!writableFromUser.destroyed) {
+            writableFromUser.write(chunk, encoding, callback);
+          } else {
+            writableForReact.destroy();
+          }
+        },
+        final(callback) {
+          debug("final");
+          onBeforeEnd();
+          writableFromUser.end();
+          onEnded();
+          callback();
+        },
+        destroy(err) {
+          debug(`destroy (\`!!err === ${!!err}\`)`);
+          if (err)
+            onReactBug(err);
+          writableFromUser.destroy(err ?? void 0);
+          onEnded();
+        }
+      });
+      const flush = () => {
+        if (typeof writableFromUser.flush === "function") {
+          ;
+          writableFromUser.flush();
+          debug("stream flushed (Node.js Writable)");
+        }
+      };
+      streamOperations.operations = {
+        flush,
+        writeChunk(chunk) {
+          writableFromUser.write(chunk);
+        }
+      };
+      writableForReact.flush = flush;
+      pipeFromReact(writableForReact);
+    };
+    return { pipeForUser: pipeForUser2, streamEnd: streamEnd2 };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createPipeWrapper
+});

package/build/runtime-cjs/server/renderToStream/createReadableWrapper.d.ts

@@ -0,0 +1,6 @@
+export { createReadableWrapper };
+declare function createReadableWrapper(readableFromReact: ReadableStream): {
+    readableForUser: ReadableStream<any>;
+    streamEnd: Promise<void>;
+    injectToStream: import("./createBuffer").InjectToStream;
+};

package/build/runtime-cjs/server/renderToStream/createReadableWrapper.js

@@ -0,0 +1,85 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var createReadableWrapper_exports = {};
+__export(createReadableWrapper_exports, {
+  createReadableWrapper: () => createReadableWrapper
+});
+module.exports = __toCommonJS(createReadableWrapper_exports);
+var import_createBuffer = require("./createBuffer");
+function createReadableWrapper(readableFromReact) {
+  const streamOperations = {
+    operations: null
+  };
+  let controllerOfUserStream;
+  let onEnded;
+  const streamEnd = new Promise((r) => {
+    onEnded = () => r();
+  });
+  const readableForUser = new ReadableStream({
+    start(controller) {
+      controllerOfUserStream = controller;
+      onReady(onEnded);
+    }
+  });
+  const { injectToStream, onBeforeWrite, onBeforeEnd } = (0, import_createBuffer.createBuffer)(streamOperations);
+  return { readableForUser, streamEnd, injectToStream };
+  async function onReady(onEnded2) {
+    streamOperations.operations = {
+      writeChunk(chunk) {
+        controllerOfUserStream.enqueue(encodeForWebStream(chunk));
+      },
+      flush: null
+    };
+    const reader = readableFromReact.getReader();
+    while (true) {
+      let result;
+      try {
+        result = await reader.read();
+      } catch (err) {
+        controllerOfUserStream.close();
+        throw err;
+      }
+      const { value, done } = result;
+      if (done) {
+        break;
+      }
+      onBeforeWrite(value);
+      streamOperations.operations.writeChunk(value);
+    }
+    setTimeout(() => {
+      onBeforeEnd();
+      controllerOfUserStream.close();
+      onEnded2();
+    }, 0);
+  }
+}
+let encoder;
+function encodeForWebStream(thing) {
+  if (!encoder) {
+    encoder = new TextEncoder();
+  }
+  if (typeof thing === "string") {
+    return encoder.encode(thing);
+  }
+  return thing;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createReadableWrapper
+});

package/build/runtime-cjs/server/renderToStream/loadNodeStreamModule.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import type { Readable as StreamNodeReadable, Writable as StreamNodeWritable } from 'stream';
+export { loadNodeStreamModule };
+export { nodeStreamModuleIsAvailable };
+type StreamModule = {
+    Readable: typeof StreamNodeReadable;
+    Writable: typeof StreamNodeWritable;
+};
+declare function loadNodeStreamModule(): Promise<StreamModule>;
+declare function nodeStreamModuleIsAvailable(): Promise<boolean>;

package/build/runtime-cjs/server/renderToStream/loadNodeStreamModule.js

@@ -0,0 +1,51 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var loadNodeStreamModule_exports = {};
+__export(loadNodeStreamModule_exports, {
+  loadNodeStreamModule: () => loadNodeStreamModule,
+  nodeStreamModuleIsAvailable: () => nodeStreamModuleIsAvailable
+});
+module.exports = __toCommonJS(loadNodeStreamModule_exports);
+async function loadNodeStreamModule() {
+  const streamModule = await loadModule();
+  const { Readable, Writable } = streamModule;
+  return { Readable, Writable };
+}
+async function nodeStreamModuleIsAvailable() {
+  try {
+    await loadModule();
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+function loadModule() {
+  return import("stream");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  loadNodeStreamModule,
+  nodeStreamModuleIsAvailable
+});

package/build/runtime-cjs/server/renderToStream/resolveSeoStrategy.d.ts

@@ -0,0 +1,9 @@
+export { resolveSeoStrategy };
+export type { SeoStrategy };
+type SeoStrategy = 'conservative' | 'google-speed';
+declare function resolveSeoStrategy(options?: {
+    seoStrategy?: SeoStrategy;
+    userAgent?: string;
+}): {
+    disableStream: boolean;
+};

package/build/runtime-cjs/server/renderToStream/resolveSeoStrategy.js

@@ -0,0 +1,44 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var resolveSeoStrategy_exports = {};
+__export(resolveSeoStrategy_exports, {
+  resolveSeoStrategy: () => resolveSeoStrategy
+});
+module.exports = __toCommonJS(resolveSeoStrategy_exports);
+var import_utils = require("../utils");
+function resolveSeoStrategy(options = {}) {
+  const seoStrategy = options.seoStrategy || "conservative";
+  if (!options.userAgent) {
+    (0, import_utils.assertWarning)(
+      false,
+      "Streaming disabled. Provide `options.userAgent` to enable streaming. (react-streaming needs the User Agent string in order to be able to disable streaming for bots, e.g. for Google Bot.) Or set `options.disable` to `true` to get rid of this warning.",
+      { onlyOnce: true }
+    );
+    return { disableStream: true };
+  }
+  const isGoogleBot = options.userAgent.toLowerCase().includes("googlebot");
+  if (seoStrategy === "google-speed" && isGoogleBot) {
+    return { disableStream: false };
+  }
+  return { disableStream: true };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolveSeoStrategy
+});

package/build/runtime-cjs/server/renderToStream.d.ts

@@ -0,0 +1,28 @@
+import React from 'react';
+import type { renderToPipeableStream as RenderToPipeableStream, renderToReadableStream as RenderToReadableStream } from 'react-dom/server';
+import { Pipe } from './renderToStream/createPipeWrapper';
+import { SeoStrategy } from './renderToStream/resolveSeoStrategy';
+export { renderToStream };
+export { disable };
+type Options = {
+    webStream?: boolean;
+    disable?: boolean;
+    seoStrategy?: SeoStrategy;
+    userAgent?: string;
+    onBoundaryError?: (err: unknown) => void;
+    renderToReadableStream?: typeof RenderToReadableStream;
+    renderToPipeableStream?: typeof RenderToPipeableStream;
+};
+type Result = ({
+    pipe: Pipe;
+    readable: null;
+} | {
+    pipe: null;
+    readable: ReadableStream;
+}) & {
+    streamEnd: Promise<boolean>;
+    disabled: boolean;
+    injectToStream: (chunk: unknown) => void;
+};
+declare function disable(): void;
+declare function renderToStream(element: React.ReactNode, options?: Options): Promise<Result>;

package/build/runtime-cjs/server/renderToStream.js

@@ -0,0 +1,183 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var renderToStream_exports = {};
+__export(renderToStream_exports, {
+  disable: () => disable,
+  renderToStream: () => renderToStream
+});
+module.exports = __toCommonJS(renderToStream_exports);
+var import_react = __toESM(require("react"));
+var import_createPipeWrapper = require("./renderToStream/createPipeWrapper");
+var import_createReadableWrapper = require("./renderToStream/createReadableWrapper");
+var import_loadNodeStreamModule = require("./renderToStream/loadNodeStreamModule");
+var import_resolveSeoStrategy = require("./renderToStream/resolveSeoStrategy");
+var import_utils = require("./utils");
+const debug = (0, import_utils.createDebugger)("react-streaming:flow");
+const globalConfig = globalThis.__react_streaming = globalThis.__react_streaming || {
+  disable: false
+};
+function disable() {
+  globalConfig.disable = true;
+}
+async function renderToStream(element, options = {}) {
+  const buffer = [];
+  let injectToStream = (chunk) => buffer.push(chunk);
+  element = import_react.default.cloneElement(element, { injectToStream });
+  const disable2 = globalConfig.disable || (options.disable ?? (0, import_resolveSeoStrategy.resolveSeoStrategy)(options).disableStream);
+  const webStream = options.webStream ?? !await (0, import_loadNodeStreamModule.nodeStreamModuleIsAvailable)();
+  debug(`disable === ${disable2} && webStream === ${webStream}`);
+  let result;
+  const resultPartial = { disabled: disable2 };
+  if (!webStream) {
+    result = { ...resultPartial, ...await renderToNodeStream(element, disable2, options) };
+  } else {
+    result = { ...resultPartial, ...await renderToWebStream(element, disable2, options) };
+  }
+  injectToStream = result.injectToStream;
+  buffer.forEach((chunk) => injectToStream(chunk));
+  buffer.length = 0;
+  debug("promise `await renderToStream()` resolved");
+  return result;
+}
+async function renderToNodeStream(element, disable2, options) {
+  debug("creating Node.js Stream Pipe");
+  let onAllReady;
+  const allReady = new Promise((r) => {
+    onAllReady = () => r();
+  });
+  let onShellReady;
+  const shellReady = new Promise((r) => {
+    onShellReady = () => r();
+  });
+  let didError = false;
+  let firstErr = null;
+  let reactBug = null;
+  const onError = (err) => {
+    debug("[react] onError() / onShellError()");
+    didError = true;
+    firstErr ??= err;
+    onShellReady();
+    afterReactBugCatch(() => {
+      if (err !== reactBug) {
+        options.onBoundaryError?.(err);
+      }
+    });
+  };
+  const renderToPipeableStream = options.renderToPipeableStream ?? (await import("react-dom/server.node")).renderToPipeableStream;
+  const { pipe: pipeOriginal } = renderToPipeableStream(element, {
+    onShellReady() {
+      debug("[react] onShellReady()");
+      onShellReady();
+    },
+    onAllReady() {
+      debug("[react] onAllReady()");
+      onShellReady();
+      onAllReady();
+    },
+    onShellError: onError,
+    onError
+  });
+  let promiseResolved = false;
+  const { pipeForUser, injectToStream, streamEnd } = await (0, import_createPipeWrapper.createPipeWrapper)(pipeOriginal, {
+    onReactBug(err) {
+      debug("react bug");
+      didError = true;
+      firstErr ??= err;
+      reactBug = err;
+      if (reactBug !== firstErr || promiseResolved) {
+        console.error(reactBug);
+      }
+    }
+  });
+  await shellReady;
+  if (didError)
+    throw firstErr;
+  if (disable2)
+    await allReady;
+  if (didError)
+    throw firstErr;
+  promiseResolved = true;
+  return {
+    pipe: pipeForUser,
+    readable: null,
+    streamEnd: wrapStreamEnd(streamEnd, didError),
+    injectToStream
+  };
+}
+async function renderToWebStream(element, disable2, options) {
+  debug("creating Web Stream Pipe");
+  let didError = false;
+  let firstErr = null;
+  let reactBug = null;
+  const onError = (err) => {
+    didError = true;
+    firstErr = firstErr || err;
+    afterReactBugCatch(() => {
+      if (err !== reactBug) {
+        options.onBoundaryError?.(err);
+      }
+    });
+  };
+  const renderToReadableStream = options.renderToReadableStream ?? (await import("react-dom/server.browser")).renderToReadableStream;
+  const readableOriginal = await renderToReadableStream(element, { onError });
+  const { allReady } = readableOriginal;
+  let promiseResolved = false;
+  allReady.catch((err) => {
+    debug("react bug");
+    didError = true;
+    firstErr = firstErr || err;
+    reactBug = err;
+    if (reactBug !== firstErr || promiseResolved) {
+      console.error(reactBug);
+    }
+  });
+  if (didError)
+    throw firstErr;
+  if (disable2)
+    await allReady;
+  if (didError)
+    throw firstErr;
+  const { readableForUser, streamEnd, injectToStream } = (0, import_createReadableWrapper.createReadableWrapper)(readableOriginal);
+  promiseResolved = true;
+  return {
+    readable: readableForUser,
+    pipe: null,
+    streamEnd: wrapStreamEnd(streamEnd, didError),
+    injectToStream
+  };
+}
+function afterReactBugCatch(fn) {
+  setTimeout(() => {
+    fn();
+  }, 0);
+}
+function wrapStreamEnd(streamEnd, didError) {
+  return streamEnd.then(() => new Promise((r) => setTimeout(r, 0))).then(() => !didError);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  disable,
+  renderToStream
+});

package/build/runtime-cjs/server/shared/initData.d.ts

@@ -0,0 +1,8 @@
+export type { InitData };
+export { initDataHtmlClass };
+type InitData = {
+    value: unknown;
+    key: string;
+    elementId: string;
+};
+declare const initDataHtmlClass = "react-streaming_initData";

package/build/runtime-cjs/server/shared/initData.js

@@ -0,0 +1,28 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var initData_exports = {};
+__export(initData_exports, {
+  initDataHtmlClass: () => initDataHtmlClass
+});
+module.exports = __toCommonJS(initData_exports);
+const initDataHtmlClass = "react-streaming_initData";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  initDataHtmlClass
+});

package/build/runtime-cjs/server/shared/key.d.ts

@@ -0,0 +1,4 @@
+export { stringifyKey };
+export { assertKey };
+declare function stringifyKey(key: unknown): string;
+declare function assertKey(keyValue: unknown): void;

package/build/runtime-cjs/server/shared/key.js

@@ -0,0 +1,45 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var key_exports = {};
+__export(key_exports, {
+  assertKey: () => assertKey,
+  stringifyKey: () => stringifyKey
+});
+module.exports = __toCommonJS(key_exports);
+var import_isCallable = require("../utils/isCallable");
+var import_utils = require("./utils");
+function stringifyKey(key) {
+  const keyString = JSON.stringify(key);
+  return keyString;
+}
+function assertKey(keyValue) {
+  (0, import_utils.assertUsage)(
+    keyValue,
+    `[useAsync(key, asyncFn)] You provided a \`key\` with the value \`${keyValue}\` which is forbidden.`
+  );
+  (0, import_utils.assertUsage)(
+    !(0, import_isCallable.isCallable)(keyValue),
+    `[useAsync(key, asyncFn)] You provided a \`key\` that is a function which is forbidden.`
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assertKey,
+  stringifyKey
+});

package/build/runtime-cjs/server/shared/utils.d.ts

@@ -0,0 +1,3 @@
+export * from '../utils/assert';
+export * from '../utils/getGlobalVariable';
+export * from '../utils/isPromise';

package/build/runtime-cjs/server/shared/utils.js

@@ -0,0 +1,20 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+module.exports = __toCommonJS(utils_exports);
+__reExport(utils_exports, require("../utils/assert"), module.exports);
+__reExport(utils_exports, require("../utils/getGlobalVariable"), module.exports);
+__reExport(utils_exports, require("../utils/isPromise"), module.exports);

package/build/runtime-cjs/server/useStream.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+export { useStream };
+export { StreamProvider };
+export type { StreamUtils };
+type StreamUtils = {
+    injectToStream: (htmlChunk: string) => void;
+};
+declare const StreamProvider: React.Provider<StreamUtils | null>;
+declare function useStream(): StreamUtils | null;