houdini-react 1.2.25 → 1.2.27

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

@@ -0,0 +1,152 @@
+import React from "react";
+import { createPipeWrapper } from "./renderToStream/createPipeWrapper";
+import { createReadableWrapper } from "./renderToStream/createReadableWrapper";
+import { nodeStreamModuleIsAvailable } from "./renderToStream/loadNodeStreamModule";
+import { resolveSeoStrategy } from "./renderToStream/resolveSeoStrategy";
+import { createDebugger } from "./utils";
+const debug = 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 = React.cloneElement(element, { injectToStream });
+  const disable2 = globalConfig.disable || (options.disable ?? resolveSeoStrategy(options).disableStream);
+  const webStream = options.webStream ?? !await 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 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 } = 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);
+}
+export {
+  disable,
+  renderToStream
+};

package/build/runtime-esm/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-esm/server/shared/initData.js

@@ -0,0 +1,4 @@
+const initDataHtmlClass = "react-streaming_initData";
+export {
+  initDataHtmlClass
+};

package/build/runtime-esm/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-esm/server/shared/key.js

@@ -0,0 +1,20 @@
+import { isCallable } from "../utils/isCallable";
+import { assertUsage } from "./utils";
+function stringifyKey(key) {
+  const keyString = JSON.stringify(key);
+  return keyString;
+}
+function assertKey(keyValue) {
+  assertUsage(
+    keyValue,
+    `[useAsync(key, asyncFn)] You provided a \`key\` with the value \`${keyValue}\` which is forbidden.`
+  );
+  assertUsage(
+    !isCallable(keyValue),
+    `[useAsync(key, asyncFn)] You provided a \`key\` that is a function which is forbidden.`
+  );
+}
+export {
+  assertKey,
+  stringifyKey
+};

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

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

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

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

package/build/runtime-esm/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;

package/build/runtime-esm/server/useStream.js

@@ -0,0 +1,13 @@
+import React, { useContext } from "react";
+import { assert } from "./utils";
+const StreamContext = React.createContext(null);
+const StreamProvider = StreamContext.Provider;
+function useStream() {
+  const streamUtils = useContext(StreamContext);
+  assert(streamUtils);
+  return streamUtils;
+}
+export {
+  StreamProvider,
+  useStream
+};

package/build/runtime-esm/server/utils/assert.d.ts

@@ -0,0 +1,15 @@
+export { assert };
+export { assertUsage };
+export { assertWarning };
+export { assertInfo };
+export { getProjectError };
+declare function assert(condition: unknown, debugInfo?: unknown): asserts condition;
+declare function assertUsage(condition: unknown, errorMessage: string): asserts condition;
+declare function getProjectError(errorMessage: string): Error;
+declare function assertWarning(condition: unknown, errorMessage: string, { onlyOnce, showStackTrace }: {
+    onlyOnce: boolean | string;
+    showStackTrace?: true;
+}): void;
+declare function assertInfo(condition: unknown, errorMessage: string, { onlyOnce }: {
+    onlyOnce: boolean;
+}): void;

package/build/runtime-esm/server/utils/assert.js

@@ -0,0 +1,91 @@
+import { createErrorWithCleanStackTrace } from "./createErrorWithCleanStackTrace";
+import { projectInfo } from "./projectInfo";
+const errorPrefix = `[${projectInfo.npmPackageName}@${projectInfo.projectVersion}]`;
+const internalErrorPrefix = `${errorPrefix}[Bug]`;
+const usageErrorPrefix = `${errorPrefix}[Wrong Usage]`;
+const warningPrefix = `${errorPrefix}[Warning]`;
+const infoPrefix = `${errorPrefix}[Info]`;
+const numberOfStackTraceLinesToRemove = 2;
+function assert(condition, debugInfo) {
+  if (condition) {
+    return;
+  }
+  const debugStr = (() => {
+    if (!debugInfo) {
+      return "";
+    }
+    const debugInfoSerialized = typeof debugInfo === "string" ? debugInfo : "`" + JSON.stringify(debugInfo) + "`";
+    return `Debug info (this is for the ${projectInfo.projectName} maintainers; you can ignore this): ${debugInfoSerialized}.`;
+  })();
+  const internalError = createErrorWithCleanStackTrace(
+    [
+      `${internalErrorPrefix} You stumbled upon a bug in ${projectInfo.projectName}'s source code.`,
+      `Reach out at ${projectInfo.githubRepository}/issues/new or ${projectInfo.discordInviteToolChannel} and include this error stack (the error stack is usually enough to fix the problem).`,
+      "A maintainer will fix the bug (usually under 24 hours).",
+      `Do not hesitate to reach out as it makes ${projectInfo.projectName} more robust.`,
+      debugStr
+    ].join(" "),
+    numberOfStackTraceLinesToRemove
+  );
+  throw internalError;
+}
+function assertUsage(condition, errorMessage) {
+  if (condition) {
+    return;
+  }
+  const whiteSpace = errorMessage.startsWith("[") ? "" : " ";
+  const usageError = createErrorWithCleanStackTrace(
+    `${usageErrorPrefix}${whiteSpace}${errorMessage}`,
+    numberOfStackTraceLinesToRemove
+  );
+  throw usageError;
+}
+function getProjectError(errorMessage) {
+  const pluginError = createErrorWithCleanStackTrace(
+    `${errorPrefix} ${errorMessage}`,
+    numberOfStackTraceLinesToRemove
+  );
+  return pluginError;
+}
+let alreadyLogged = /* @__PURE__ */ new Set();
+function assertWarning(condition, errorMessage, { onlyOnce, showStackTrace }) {
+  if (condition) {
+    return;
+  }
+  const msg = `${warningPrefix} ${errorMessage}`;
+  if (onlyOnce) {
+    const key = onlyOnce === true ? msg : onlyOnce;
+    if (alreadyLogged.has(key)) {
+      return;
+    } else {
+      alreadyLogged.add(key);
+    }
+  }
+  if (showStackTrace) {
+    console.warn(new Error(msg));
+  } else {
+    console.warn(msg);
+  }
+}
+function assertInfo(condition, errorMessage, { onlyOnce }) {
+  if (condition) {
+    return;
+  }
+  const msg = `${infoPrefix} ${errorMessage}`;
+  if (onlyOnce) {
+    const key = msg;
+    if (alreadyLogged.has(key)) {
+      return;
+    } else {
+      alreadyLogged.add(key);
+    }
+  }
+  console.log(msg);
+}
+export {
+  assert,
+  assertInfo,
+  assertUsage,
+  assertWarning,
+  getProjectError
+};

package/build/runtime-esm/server/utils/createErrorWithCleanStackTrace.d.ts

@@ -0,0 +1,2 @@
+export { createErrorWithCleanStackTrace };
+declare function createErrorWithCleanStackTrace(errorMessage: string, numberOfStackTraceLinesToRemove: number): Error;

package/build/runtime-esm/server/utils/createErrorWithCleanStackTrace.js

@@ -0,0 +1,38 @@
+function createErrorWithCleanStackTrace(errorMessage, numberOfStackTraceLinesToRemove) {
+  let err;
+  {
+    var stackTraceLimit__original = Error.stackTraceLimit;
+    Error.stackTraceLimit = Infinity;
+    err = new Error(errorMessage);
+    Error.stackTraceLimit = stackTraceLimit__original;
+  }
+  err.stack = clean(err.stack, numberOfStackTraceLinesToRemove);
+  return err;
+}
+function clean(errStack, numberOfStackTraceLinesToRemove) {
+  if (!errStack) {
+    return errStack;
+  }
+  const stackLines = splitByLine(errStack);
+  let linesRemoved = 0;
+  const stackLine__cleaned = stackLines.filter((line) => {
+    if (line.includes(" (internal/") || line.includes(" (node:internal")) {
+      return false;
+    }
+    if (linesRemoved < numberOfStackTraceLinesToRemove && isStackTraceLine(line)) {
+      linesRemoved++;
+      return false;
+    }
+    return true;
+  }).join("\n");
+  return stackLine__cleaned;
+}
+function isStackTraceLine(line) {
+  return line.startsWith("    at ");
+}
+function splitByLine(str) {
+  return str.split(/\r?\n/);
+}
+export {
+  createErrorWithCleanStackTrace
+};

package/build/runtime-esm/server/utils/debug.d.ts

@@ -0,0 +1,14 @@
+export { createDebugger };
+export { isDebugEnabled };
+export type { Debug };
+type Debug = ReturnType<typeof createDebugger>;
+type Options = {
+    serialization?: {
+        emptyArray?: string;
+    };
+};
+declare function createDebugger(namespace: string, optionsGlobal?: Options): ((msg: string, info?: unknown) => void) & {
+    options: (options: Options) => (msg: string, info?: unknown) => void;
+    isEnabled: boolean;
+};
+declare function isDebugEnabled(namespace: string): boolean;

package/build/runtime-esm/server/utils/debug.js

@@ -0,0 +1,87 @@
+import { assert } from "./assert";
+import { isBrowser } from "./isBrowser";
+import { isCallable } from "./isCallable";
+import { objectAssign } from "./objectAssign";
+assert(!isBrowser(), "utils/debug.js loaded in browser");
+globalThis.__brillout_debug_createDebugger = createDebugger;
+function createDebugger(namespace, optionsGlobal) {
+  const debugWithOptions = (options) => {
+    return (msg, info) => {
+      if (!isDebugEnabled(namespace))
+        return;
+      if (info !== void 0) {
+        msg += strInfo(info, { ...optionsGlobal, ...options });
+      }
+      console.log("\x1B[1m%s\x1B[0m", namespace, msg);
+    };
+  };
+  const debug = (msg, info) => debugWithOptions({})(msg, info);
+  objectAssign(debug, { options: debugWithOptions, isEnabled: isDebugEnabled(namespace) });
+  return debug;
+}
+function isDebugEnabled(namespace) {
+  let DEBUG;
+  try {
+    DEBUG = process.env.DEBUG;
+  } catch {
+  }
+  return DEBUG?.includes(namespace) ?? false;
+}
+function strInfo(info, options) {
+  if (info === void 0) {
+    return void 0;
+  }
+  let str = "\n";
+  if (typeof info === "string") {
+    str += info;
+  } else if (Array.isArray(info)) {
+    if (info.length === 0) {
+      str += options.serialization?.emptyArray ?? "[]";
+    } else {
+      str += info.map(strUnknown).join("\n");
+    }
+  } else {
+    str += strUnknown(info);
+  }
+  str = pad(str);
+  return str;
+}
+function pad(str) {
+  const PADDING = "     ";
+  const WIDTH = process.stdout.columns;
+  const lines = [];
+  str.split("\n").forEach((line) => {
+    if (!WIDTH) {
+      lines.push(line);
+    } else {
+      chunk(line, WIDTH - PADDING.length).forEach((chunk2) => {
+        lines.push(chunk2);
+      });
+    }
+  });
+  return lines.join("\n" + PADDING);
+}
+function chunk(str, size) {
+  if (str.length <= size) {
+    return [str];
+  }
+  const chunks = str.match(new RegExp(".{1," + size + "}", "g"));
+  assert(chunks);
+  return chunks;
+}
+function strUnknown(thing) {
+  return typeof thing === "string" ? thing : strObj(thing);
+}
+function strObj(obj, newLines = false) {
+  return JSON.stringify(obj, replaceFunctionSerializer, newLines ? 2 : void 0);
+}
+function replaceFunctionSerializer(_key, value) {
+  if (isCallable(value)) {
+    return value.toString().split(/\s+/).join(" ");
+  }
+  return value;
+}
+export {
+  createDebugger,
+  isDebugEnabled
+};

package/build/runtime-esm/server/utils/getGlobalVariable.d.ts

@@ -0,0 +1,4 @@
+export declare function getGlobalVariable<T>(key: string, defaultValue: T): T;
+declare global {
+    var __react_streaming: Record<string, any>;
+}

package/build/runtime-esm/server/utils/getGlobalVariable.js

@@ -0,0 +1,8 @@
+function getGlobalVariable(key, defaultValue) {
+  globalThis.__react_streaming = globalThis.__react_streaming || {};
+  globalThis.__react_streaming[key] = globalThis.__react_streaming[key] || defaultValue;
+  return globalThis.__react_streaming[key];
+}
+export {
+  getGlobalVariable
+};

package/build/runtime-esm/server/utils/isBrowser.d.ts

@@ -0,0 +1,2 @@
+export { isBrowser };
+declare function isBrowser(): boolean;

package/build/runtime-esm/server/utils/isBrowser.js

@@ -0,0 +1,6 @@
+function isBrowser() {
+  return typeof window !== "undefined" && typeof window.scrollY === "number";
+}
+export {
+  isBrowser
+};

package/build/runtime-esm/server/utils/isCallable.d.ts

@@ -0,0 +1,2 @@
+export { isCallable };
+declare function isCallable<T extends (...args: unknown[]) => unknown>(thing: T | unknown): thing is T;

package/build/runtime-esm/server/utils/isCallable.js

@@ -0,0 +1,6 @@
+function isCallable(thing) {
+  return thing instanceof Function || typeof thing === "function";
+}
+export {
+  isCallable
+};

package/build/runtime-esm/server/utils/isClientSide.d.ts

@@ -0,0 +1,2 @@
+export { isClientSide };
+declare function isClientSide(): boolean;

package/build/runtime-esm/server/utils/isClientSide.js

@@ -0,0 +1,6 @@
+function isClientSide() {
+  return typeof window !== "undefined" && typeof window?.getComputedStyle === "function";
+}
+export {
+  isClientSide
+};

package/build/runtime-esm/server/utils/isPromise.d.ts

@@ -0,0 +1 @@
+export declare function isPromise(val: unknown): val is Promise<unknown>;

package/build/runtime-esm/server/utils/isPromise.js

@@ -0,0 +1,7 @@
+import { isCallable } from "./isCallable";
+function isPromise(val) {
+  return typeof val === "object" && val !== null && "then" in val && isCallable(val.then);
+}
+export {
+  isPromise
+};

package/build/runtime-esm/server/utils/isServerSide.d.ts

@@ -0,0 +1,2 @@
+export { isServerSide };
+declare function isServerSide(): boolean;

package/build/runtime-esm/server/utils/isServerSide.js

@@ -0,0 +1,7 @@
+import { isClientSide } from "./isClientSide";
+function isServerSide() {
+  return !isClientSide();
+}
+export {
+  isServerSide
+};

package/build/runtime-esm/server/utils/objectAssign.d.ts

@@ -0,0 +1,2 @@
+export { objectAssign };
+declare function objectAssign<Obj extends object, ObjAddendum>(obj: Obj, objAddendum: ObjAddendum): asserts obj is Obj & ObjAddendum;

package/build/runtime-esm/server/utils/objectAssign.js

@@ -0,0 +1,6 @@
+function objectAssign(obj, objAddendum) {
+  Object.assign(obj, objAddendum);
+}
+export {
+  objectAssign
+};

package/build/runtime-esm/server/utils/projectInfo.d.ts

@@ -0,0 +1,10 @@
+export declare const projectInfo: {
+    projectName: "react-streaming";
+    projectVersion: string;
+    npmPackageName: "react-streaming";
+    githubRepository: "https://github.com/brillout/react-streaming";
+    discordInviteToolChannel: "https://discord.com/invite/H23tjRxFvx";
+};
+declare global {
+    var __vite_plugin_ssr__instances: undefined | string[];
+}

package/build/runtime-esm/server/utils/projectInfo.js

@@ -0,0 +1,13 @@
+const PROJECT_VERSION = "0.3.14";
+const projectInfo = {
+  projectName: "react-streaming",
+  projectVersion: PROJECT_VERSION,
+  npmPackageName: "react-streaming",
+  githubRepository: "https://github.com/brillout/react-streaming",
+  discordInviteToolChannel: "https://discord.com/invite/H23tjRxFvx"
+};
+globalThis.__vite_plugin_ssr__instances = globalThis.__vite_plugin_ssr__instances || [];
+globalThis.__vite_plugin_ssr__instances.push(projectInfo.projectVersion);
+export {
+  projectInfo
+};

package/build/runtime-esm/server/utils.d.ts

@@ -0,0 +1,4 @@
+export * from './utils/assert';
+export * from './utils/debug';
+export * from './utils/isPromise';
+export * from './utils/isBrowser';

package/build/runtime-esm/server/utils.js

@@ -0,0 +1,4 @@
+export * from "./utils/assert";
+export * from "./utils/debug";
+export * from "./utils/isPromise";
+export * from "./utils/isBrowser";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "houdini-react",
-  "version": "1.2.25",
+  "version": "1.2.27",
   "description": "The React plugin for houdini",
   "keywords": [
     "typescript",
@@ -21,7 +21,7 @@
     "@types/cookies": "^0.7.7",
     "@types/estraverse": "^5.1.2",
     "@types/express": "^4.17.17",
-    "@types/react-dom": "^18.0.10",
+    "@types/react-dom": "^18.0.11",
     "next": "^13.0.1",
     "scripts": "^1.0.0"
   },
@@ -38,11 +38,11 @@
     "graphql": "^15.8.0",
     "graphql-yoga": "^4.0.4",
     "react": "^18.2.0",
-    "react-streaming": "^0.3.9",
+    "react-dom": "^18.2.0",
     "recast": "^0.23.1",
     "rollup": "^3.7.4",
     "use-deep-compare-effect": "^1.8.1",
-    "houdini": "^1.2.25"
+    "houdini": "^1.2.27"
   },
   "files": [
     "build"