houdini-react 1.2.24 → 1.2.26

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.24",
+  "version": "1.2.26",
   "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.24"
+    "houdini": "^1.2.26"
   },
   "files": [
     "build"