@rstreamlabs/react 1.1.0

package/README.md

@@ -0,0 +1,3 @@
+# `@rstreamlabs/react`
+
+React hooks and components for building rstream-enabled UIs.

package/dist/index.d.mts

@@ -0,0 +1,90 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ITerminalOptions, Terminal } from '@xterm/xterm';
+import { WebTTYClientConfig, WebTTYExecutionConfig, WebTTYEvents } from '@rstreamlabs/webtty';
+import { RstreamAuth } from '@rstreamlabs/rstream';
+
+interface WebTTYTerminalProps extends WebTTYClientConfig, WebTTYExecutionConfig, WebTTYEvents {
+    /**
+     * xterm.js TerminalOptions override
+     */
+    terminalOptions?: ITerminalOptions;
+    /**
+     * Called once the xterm Terminal is created (before connect).
+     * Can be used to add your own add-ons or manipulate the Terminal instance.
+     */
+    onTerminalCreated?: (terminal: Terminal) => void;
+}
+/**
+ * A React component that binds a WebTTY session to an xterm.js instance.
+ */
+declare function WebTTYTerminal(props: WebTTYTerminalProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Configuration for the UseRstream hook.
+ */
+interface UseRstreamOptions {
+    /**
+     * Short-term authentication token provider.
+     */
+    auth?: RstreamAuth;
+    /**
+     * Timeout (in milliseconds) to wait before attempting to reconnect
+     * after the SSE connection is closed.
+     *
+     * @default 1000
+     */
+    reconnectTimeout?: number;
+    /**
+     * Timeout (in milliseconds) to wait before showing an error message
+     * when the connection is not yet established.
+     *
+     * @default 5000
+     */
+    errorTimeout?: number;
+}
+/**
+ * A React hook to subscribe to rstream resources.
+ *
+ * This hook fetches the list of clients and tunnels from the rstream API.
+ * It handles automatic reconnection and displays a warning if the connection
+ * is not established within the timeout.
+ *
+ * @param options - The configuration options for the hook.
+ * @returns An object with the current error (if any), and arrays of tunnels and clients.
+ */
+declare function useRstream(options?: UseRstreamOptions): {
+    error: {
+        message: string;
+        type: "warning" | "danger";
+    } | null;
+    tunnels: {
+        status: "online" | "offline";
+        id: string;
+        client_id: string;
+        user_id: string;
+        protocol: string;
+        publish: boolean;
+        tls_mode: string;
+        mtls: boolean;
+        token_auth: boolean;
+        path?: string | undefined;
+        name?: string | undefined;
+        labels?: Record<string, string | undefined> | undefined;
+        host?: string | undefined;
+        tls_min_version?: string | undefined;
+    }[];
+    clients: {
+        status: "online" | "offline";
+        id: string;
+        user_id: string;
+        labels?: Record<string, string | undefined> | undefined;
+        details?: {
+            agent?: string | undefined;
+            os?: string | undefined;
+            version?: string | undefined;
+            protocol_version?: string | undefined;
+        } | undefined;
+    }[];
+};
+
+export { type UseRstreamOptions, WebTTYTerminal, type WebTTYTerminalProps, useRstream };

package/dist/index.d.ts

@@ -0,0 +1,90 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ITerminalOptions, Terminal } from '@xterm/xterm';
+import { WebTTYClientConfig, WebTTYExecutionConfig, WebTTYEvents } from '@rstreamlabs/webtty';
+import { RstreamAuth } from '@rstreamlabs/rstream';
+
+interface WebTTYTerminalProps extends WebTTYClientConfig, WebTTYExecutionConfig, WebTTYEvents {
+    /**
+     * xterm.js TerminalOptions override
+     */
+    terminalOptions?: ITerminalOptions;
+    /**
+     * Called once the xterm Terminal is created (before connect).
+     * Can be used to add your own add-ons or manipulate the Terminal instance.
+     */
+    onTerminalCreated?: (terminal: Terminal) => void;
+}
+/**
+ * A React component that binds a WebTTY session to an xterm.js instance.
+ */
+declare function WebTTYTerminal(props: WebTTYTerminalProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Configuration for the UseRstream hook.
+ */
+interface UseRstreamOptions {
+    /**
+     * Short-term authentication token provider.
+     */
+    auth?: RstreamAuth;
+    /**
+     * Timeout (in milliseconds) to wait before attempting to reconnect
+     * after the SSE connection is closed.
+     *
+     * @default 1000
+     */
+    reconnectTimeout?: number;
+    /**
+     * Timeout (in milliseconds) to wait before showing an error message
+     * when the connection is not yet established.
+     *
+     * @default 5000
+     */
+    errorTimeout?: number;
+}
+/**
+ * A React hook to subscribe to rstream resources.
+ *
+ * This hook fetches the list of clients and tunnels from the rstream API.
+ * It handles automatic reconnection and displays a warning if the connection
+ * is not established within the timeout.
+ *
+ * @param options - The configuration options for the hook.
+ * @returns An object with the current error (if any), and arrays of tunnels and clients.
+ */
+declare function useRstream(options?: UseRstreamOptions): {
+    error: {
+        message: string;
+        type: "warning" | "danger";
+    } | null;
+    tunnels: {
+        status: "online" | "offline";
+        id: string;
+        client_id: string;
+        user_id: string;
+        protocol: string;
+        publish: boolean;
+        tls_mode: string;
+        mtls: boolean;
+        token_auth: boolean;
+        path?: string | undefined;
+        name?: string | undefined;
+        labels?: Record<string, string | undefined> | undefined;
+        host?: string | undefined;
+        tls_min_version?: string | undefined;
+    }[];
+    clients: {
+        status: "online" | "offline";
+        id: string;
+        user_id: string;
+        labels?: Record<string, string | undefined> | undefined;
+        details?: {
+            agent?: string | undefined;
+            os?: string | undefined;
+            version?: string | undefined;
+            protocol_version?: string | undefined;
+        } | undefined;
+    }[];
+};
+
+export { type UseRstreamOptions, WebTTYTerminal, type WebTTYTerminalProps, useRstream };

package/dist/index.js

@@ -0,0 +1,305 @@
+"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(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  WebTTYTerminal: () => WebTTYTerminal,
+  useRstream: () => useRstream
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/components/webtty.tsx
+var import_xterm = require("@xterm/xterm/css/xterm.css");
+var import_addon_fit = require("@xterm/addon-fit");
+var import_xterm2 = require("@xterm/xterm");
+var import_addon_unicode11 = require("@xterm/addon-unicode11");
+var import_addon_webgl = require("@xterm/addon-webgl");
+var import_addon_web_links = require("@xterm/addon-web-links");
+var import_webtty = require("@rstreamlabs/webtty");
+var React = __toESM(require("react"));
+var import_jsx_runtime = require("react/jsx-runtime");
+function WebTTYTerminal(props) {
+  const {
+    // WebTTY client config
+    url,
+    sendHeartbeat,
+    heartbeatIntervalMs,
+    // Execution config
+    cmdArgs,
+    envVars,
+    allocateTty,
+    interactive,
+    username,
+    workdir,
+    // Events
+    onStdout,
+    onStdoutEos,
+    onStderr,
+    onStderrEos,
+    onConnect,
+    onComplete,
+    onError,
+    // xterm.js options
+    terminalOptions,
+    // Callbacks
+    onTerminalCreated
+  } = props;
+  const ref = React.useRef(null);
+  React.useEffect(() => {
+    if (!ref.current) {
+      return;
+    }
+    let disposeOnData = null;
+    let disposeOnResize = null;
+    let resizeObserver = null;
+    const clear = () => {
+      disposeOnData?.dispose();
+      disposeOnData = null;
+      disposeOnResize?.dispose();
+      disposeOnResize = null;
+      resizeObserver?.disconnect();
+      resizeObserver = null;
+    };
+    const terminal = new import_xterm2.Terminal({
+      allowProposedApi: true,
+      cursorBlink: false,
+      scrollback: 1e4,
+      ...terminalOptions
+    });
+    const fitAddon = new import_addon_fit.FitAddon();
+    terminal.loadAddon(fitAddon);
+    terminal.loadAddon(new import_addon_web_links.WebLinksAddon());
+    terminal.loadAddon(new import_addon_unicode11.Unicode11Addon());
+    try {
+      terminal.loadAddon(new import_addon_webgl.WebglAddon());
+    } catch (err) {
+      console.warn("WebGL addon could not be loaded:", err);
+    }
+    terminal.open(ref.current);
+    onTerminalCreated?.(terminal);
+    const webtty = new import_webtty.WebTTY(
+      { url, sendHeartbeat, heartbeatIntervalMs },
+      { cmdArgs, envVars, allocateTty, interactive, username, workdir },
+      {
+        onStdout: (chunk) => {
+          onStdout?.(chunk);
+          terminal.write(chunk);
+        },
+        onStdoutEos: () => {
+          onStdoutEos?.();
+        },
+        onStderr: (chunk) => {
+          onStderr?.(chunk);
+          terminal.write(
+            "\x1B[31m" + new TextDecoder().decode(chunk) + "\x1B[0m"
+          );
+        },
+        onStderrEos: () => {
+          onStderrEos?.();
+        },
+        onConnect: () => {
+          onConnect?.();
+          terminal.focus();
+          try {
+            webtty.resize(terminal.rows, terminal.cols);
+          } catch (e) {
+            console.error("Cannot resize remote TTY:", e);
+          }
+          disposeOnData = terminal.onData((data) => {
+            try {
+              webtty.writeStdin(new TextEncoder().encode(data));
+            } catch (e) {
+              console.error("Cannot writeStdin:", e);
+            }
+          });
+          disposeOnResize = terminal.onResize((size) => {
+            try {
+              webtty.resize(size.rows, size.cols);
+            } catch (e) {
+              console.error("Cannot resize remote TTY:", e);
+            }
+          });
+        },
+        onComplete: (code) => {
+          onComplete?.(code);
+          terminal.write(`\r
+Process exited with code ${code}\r
+`);
+          clear();
+        },
+        onError: (err) => {
+          onError?.(err);
+          terminal.write(`\r
+[ERROR] ${err}\r
+`);
+          clear();
+        }
+      }
+    );
+    webtty.connect();
+    resizeObserver = new ResizeObserver((entries) => {
+      for (const entry of entries) {
+        if (entry.target === ref.current) {
+          fitAddon.fit();
+        }
+      }
+    });
+    resizeObserver.observe(ref.current);
+    return () => {
+      clear();
+      terminal.dispose();
+    };
+  });
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref, style: { height: "100%", width: "100%" } });
+}
+
+// src/hooks/use-rstream.ts
+var import_rstream = require("@rstreamlabs/rstream");
+var React2 = __toESM(require("react"));
+function useRstream(options) {
+  const [state, setState] = React2.useState("disconnected");
+  const [error, setError] = React2.useState(null);
+  const { reconnectTimeout = 1e3, errorTimeout = 5e3 } = options || {};
+  const [clients, setClients] = React2.useState([]);
+  const [tunnels, setTunnels] = React2.useState([]);
+  React2.useEffect(() => {
+    if (!options?.auth) return;
+    let active = true;
+    let watch = null;
+    let timeout = null;
+    const run = async () => {
+      if (!options?.auth) return;
+      setState("connecting");
+      watch = new import_rstream.Watch(
+        { auth: options.auth },
+        {
+          onEvent: (event) => {
+            if (!active) return;
+            if (event.type.startsWith("client")) {
+              setClients((previous) => {
+                if (event.type === "client.created") {
+                  return [...previous, event.object];
+                } else if (event.type === "client.updated") {
+                  return previous.map((client) => {
+                    if (client.id === event.object.id) {
+                      return event.object;
+                    }
+                    return client;
+                  });
+                } else if (event.type === "client.deleted") {
+                  return previous.filter(
+                    (client) => client.id !== event.object.id
+                  );
+                }
+                return previous;
+              });
+            } else if (event.type.startsWith("tunnel")) {
+              setTunnels((previous) => {
+                if (event.type === "tunnel.created") {
+                  return [...previous, event.object];
+                } else if (event.type === "tunnel.updated") {
+                  return previous.map((tunnel) => {
+                    if (tunnel.id === event.object.id) {
+                      return event.object;
+                    }
+                    return tunnel;
+                  });
+                } else if (event.type === "tunnel.deleted") {
+                  return previous.filter(
+                    (tunnel) => tunnel.id !== event.object.id
+                  );
+                }
+                return previous;
+              });
+            }
+          },
+          onConnect: () => {
+            if (!active) return;
+            setState("connected");
+          },
+          onClose: () => {
+            if (!active) return;
+            watch = null;
+            setState("connecting");
+            timeout = setTimeout(() => {
+              if (!active) return;
+              timeout = null;
+              run();
+            }, reconnectTimeout);
+          }
+        }
+      );
+    };
+    run();
+    return () => {
+      active = false;
+      if (watch) {
+        watch.disconnect();
+        watch = null;
+      }
+      if (timeout) {
+        clearTimeout(timeout);
+        timeout = null;
+      }
+    };
+  }, [options, reconnectTimeout]);
+  React2.useEffect(() => {
+    if (options?.auth) {
+      if (error && error.type === "danger") return;
+      if (state !== "connected") {
+        const timeout = setTimeout(() => {
+          setError({
+            message: "Failed to fetch rstream ressources. Retrying...",
+            type: "warning"
+          });
+        }, errorTimeout);
+        return () => {
+          clearTimeout(timeout);
+        };
+      } else if (state === "connected") {
+        setError(null);
+      }
+    } else {
+      setError(null);
+    }
+  }, [options, state, error, errorTimeout]);
+  React2.useEffect(() => {
+    if (options?.auth === void 0 || state !== "connected") {
+      setClients([]);
+      setTunnels([]);
+    }
+  }, [options, state]);
+  return { error, tunnels, clients };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WebTTYTerminal,
+  useRstream
+});

package/dist/index.mjs

@@ -0,0 +1,269 @@
+// src/components/webtty.tsx
+import "@xterm/xterm/css/xterm.css";
+import { FitAddon } from "@xterm/addon-fit";
+import { Terminal } from "@xterm/xterm";
+import { Unicode11Addon } from "@xterm/addon-unicode11";
+import { WebglAddon } from "@xterm/addon-webgl";
+import { WebLinksAddon } from "@xterm/addon-web-links";
+import {
+  WebTTY
+} from "@rstreamlabs/webtty";
+import * as React from "react";
+import { jsx } from "react/jsx-runtime";
+function WebTTYTerminal(props) {
+  const {
+    // WebTTY client config
+    url,
+    sendHeartbeat,
+    heartbeatIntervalMs,
+    // Execution config
+    cmdArgs,
+    envVars,
+    allocateTty,
+    interactive,
+    username,
+    workdir,
+    // Events
+    onStdout,
+    onStdoutEos,
+    onStderr,
+    onStderrEos,
+    onConnect,
+    onComplete,
+    onError,
+    // xterm.js options
+    terminalOptions,
+    // Callbacks
+    onTerminalCreated
+  } = props;
+  const ref = React.useRef(null);
+  React.useEffect(() => {
+    if (!ref.current) {
+      return;
+    }
+    let disposeOnData = null;
+    let disposeOnResize = null;
+    let resizeObserver = null;
+    const clear = () => {
+      disposeOnData?.dispose();
+      disposeOnData = null;
+      disposeOnResize?.dispose();
+      disposeOnResize = null;
+      resizeObserver?.disconnect();
+      resizeObserver = null;
+    };
+    const terminal = new Terminal({
+      allowProposedApi: true,
+      cursorBlink: false,
+      scrollback: 1e4,
+      ...terminalOptions
+    });
+    const fitAddon = new FitAddon();
+    terminal.loadAddon(fitAddon);
+    terminal.loadAddon(new WebLinksAddon());
+    terminal.loadAddon(new Unicode11Addon());
+    try {
+      terminal.loadAddon(new WebglAddon());
+    } catch (err) {
+      console.warn("WebGL addon could not be loaded:", err);
+    }
+    terminal.open(ref.current);
+    onTerminalCreated?.(terminal);
+    const webtty = new WebTTY(
+      { url, sendHeartbeat, heartbeatIntervalMs },
+      { cmdArgs, envVars, allocateTty, interactive, username, workdir },
+      {
+        onStdout: (chunk) => {
+          onStdout?.(chunk);
+          terminal.write(chunk);
+        },
+        onStdoutEos: () => {
+          onStdoutEos?.();
+        },
+        onStderr: (chunk) => {
+          onStderr?.(chunk);
+          terminal.write(
+            "\x1B[31m" + new TextDecoder().decode(chunk) + "\x1B[0m"
+          );
+        },
+        onStderrEos: () => {
+          onStderrEos?.();
+        },
+        onConnect: () => {
+          onConnect?.();
+          terminal.focus();
+          try {
+            webtty.resize(terminal.rows, terminal.cols);
+          } catch (e) {
+            console.error("Cannot resize remote TTY:", e);
+          }
+          disposeOnData = terminal.onData((data) => {
+            try {
+              webtty.writeStdin(new TextEncoder().encode(data));
+            } catch (e) {
+              console.error("Cannot writeStdin:", e);
+            }
+          });
+          disposeOnResize = terminal.onResize((size) => {
+            try {
+              webtty.resize(size.rows, size.cols);
+            } catch (e) {
+              console.error("Cannot resize remote TTY:", e);
+            }
+          });
+        },
+        onComplete: (code) => {
+          onComplete?.(code);
+          terminal.write(`\r
+Process exited with code ${code}\r
+`);
+          clear();
+        },
+        onError: (err) => {
+          onError?.(err);
+          terminal.write(`\r
+[ERROR] ${err}\r
+`);
+          clear();
+        }
+      }
+    );
+    webtty.connect();
+    resizeObserver = new ResizeObserver((entries) => {
+      for (const entry of entries) {
+        if (entry.target === ref.current) {
+          fitAddon.fit();
+        }
+      }
+    });
+    resizeObserver.observe(ref.current);
+    return () => {
+      clear();
+      terminal.dispose();
+    };
+  });
+  return /* @__PURE__ */ jsx("div", { ref, style: { height: "100%", width: "100%" } });
+}
+
+// src/hooks/use-rstream.ts
+import { Watch } from "@rstreamlabs/rstream";
+import * as React2 from "react";
+function useRstream(options) {
+  const [state, setState] = React2.useState("disconnected");
+  const [error, setError] = React2.useState(null);
+  const { reconnectTimeout = 1e3, errorTimeout = 5e3 } = options || {};
+  const [clients, setClients] = React2.useState([]);
+  const [tunnels, setTunnels] = React2.useState([]);
+  React2.useEffect(() => {
+    if (!options?.auth) return;
+    let active = true;
+    let watch = null;
+    let timeout = null;
+    const run = async () => {
+      if (!options?.auth) return;
+      setState("connecting");
+      watch = new Watch(
+        { auth: options.auth },
+        {
+          onEvent: (event) => {
+            if (!active) return;
+            if (event.type.startsWith("client")) {
+              setClients((previous) => {
+                if (event.type === "client.created") {
+                  return [...previous, event.object];
+                } else if (event.type === "client.updated") {
+                  return previous.map((client) => {
+                    if (client.id === event.object.id) {
+                      return event.object;
+                    }
+                    return client;
+                  });
+                } else if (event.type === "client.deleted") {
+                  return previous.filter(
+                    (client) => client.id !== event.object.id
+                  );
+                }
+                return previous;
+              });
+            } else if (event.type.startsWith("tunnel")) {
+              setTunnels((previous) => {
+                if (event.type === "tunnel.created") {
+                  return [...previous, event.object];
+                } else if (event.type === "tunnel.updated") {
+                  return previous.map((tunnel) => {
+                    if (tunnel.id === event.object.id) {
+                      return event.object;
+                    }
+                    return tunnel;
+                  });
+                } else if (event.type === "tunnel.deleted") {
+                  return previous.filter(
+                    (tunnel) => tunnel.id !== event.object.id
+                  );
+                }
+                return previous;
+              });
+            }
+          },
+          onConnect: () => {
+            if (!active) return;
+            setState("connected");
+          },
+          onClose: () => {
+            if (!active) return;
+            watch = null;
+            setState("connecting");
+            timeout = setTimeout(() => {
+              if (!active) return;
+              timeout = null;
+              run();
+            }, reconnectTimeout);
+          }
+        }
+      );
+    };
+    run();
+    return () => {
+      active = false;
+      if (watch) {
+        watch.disconnect();
+        watch = null;
+      }
+      if (timeout) {
+        clearTimeout(timeout);
+        timeout = null;
+      }
+    };
+  }, [options, reconnectTimeout]);
+  React2.useEffect(() => {
+    if (options?.auth) {
+      if (error && error.type === "danger") return;
+      if (state !== "connected") {
+        const timeout = setTimeout(() => {
+          setError({
+            message: "Failed to fetch rstream ressources. Retrying...",
+            type: "warning"
+          });
+        }, errorTimeout);
+        return () => {
+          clearTimeout(timeout);
+        };
+      } else if (state === "connected") {
+        setError(null);
+      }
+    } else {
+      setError(null);
+    }
+  }, [options, state, error, errorTimeout]);
+  React2.useEffect(() => {
+    if (options?.auth === void 0 || state !== "connected") {
+      setClients([]);
+      setTunnels([]);
+    }
+  }, [options, state]);
+  return { error, tunnels, clients };
+}
+export {
+  WebTTYTerminal,
+  useRstream
+};

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@rstreamlabs/react",
+  "version": "1.1.0",
+  "description": "React hooks and components for building rstream-enabled UIs.",
+  "license": "Apache-2.0",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build:watch": "tsup --watch",
+    "build": "tsup",
+    "clean": "rm -rf dist",
+    "lint": "eslint \"./**/*.ts*\"",
+    "type-check": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@turbo/gen": "^2.4.0",
+    "@types/node": "^22.13.1",
+    "@types/react-dom": "19.0.3",
+    "@types/react": "19.0.8",
+    "eslint-config": "*",
+    "typescript-config": "*",
+    "typescript": "5.7.3"
+  },
+  "dependencies": {
+    "@rstreamlabs/rstream": "1.1.0",
+    "@rstreamlabs/webtty": "1.1.0",
+    "@xterm/addon-fit": "^0.10.0",
+    "@xterm/addon-unicode11": "^0.8.0",
+    "@xterm/addon-web-links": "^0.11.0",
+    "@xterm/addon-webgl": "^0.18.0",
+    "@xterm/xterm": "^5.5.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
+  },
+  "peerDependencies": {
+    "@types/react": "*",
+    "react": "^18.0 || ^19.0"
+  },
+  "peerDependenciesMeta": {
+    "@types/react": {
+      "optional": true
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}