@dotwire/react 0.0.0-stage → 0.2.1

package/LICENSE

@@ -0,0 +1,176 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or exemplary damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS

package/README.md

@@ -1,3 +1,134 @@
-# Temporary Holding Version
+# @dotwire/react
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+For coding agents adding dotwire to an application, see the [SDK integration guide](https://github.com/pasztor-mark/dotwire/blob/main/docs/SDK_AGENT_GUIDE.md).
+
+React hooks and a provider for [`@dotwire/client`](https://www.npmjs.com/package/@dotwire/client), the TypeScript/JavaScript SDK
+for **dotwire**, the high-throughput, self-hosted real-time messaging infrastructure.
+
+[![License](https://img.shields.io/badge/License-Apache%202.0-green.svg)](https://github.com/pasztor-mark/dotwire)
+
+## Installation
+
+```bash
+npm install @dotwire/react @dotwire/client react
+```
+
+`react` (>= 18) and `@dotwire/client` are peer dependencies — install them alongside this
+package. Every export in this package is client-only (it uses hooks and context); the bundle
+carries a `"use client"` banner for React Server Components frameworks.
+
+## Quickstart
+
+```tsx
+import { DotwireProvider, useRoom, useTyping, usePresence, useConnectionState } from '@dotwire/react';
+
+const dotwireOptions = {
+  baseUrl: 'https://chat.yourdomain.com',
+  tokenUrl: '/api/auth/token'
+};
+
+function App() {
+  return (
+    <DotwireProvider options={dotwireOptions}>
+      <Room roomId="a0000000-0000-0000-0000-000000000001" />
+    </DotwireProvider>
+  );
+}
+
+function Room({ roomId }: { roomId: string }) {
+  const connectionState = useConnectionState();
+  const { messages, status, hasMore, loadOlder, send } = useRoom(roomId, { history: 50 });
+  const { typingUsers, notifyTyping, stopTyping } = useTyping(roomId);
+  const { present } = usePresence(roomId);
+
+  return (
+    <div>
+      <p>Connection: {connectionState}</p>
+      <p>Room: {status}</p>
+      {hasMore && <button onClick={loadOlder}>Load older</button>}
+      <ul>
+        {messages.map((m) => (
+          <li key={m.seq}>
+            #{m.seq} {m.senderId}: {m.content}
+          </li>
+        ))}
+      </ul>
+      <p>Typing: {typingUsers.join(', ') || '—'}</p>
+      <p>Present: {present.join(', ') || '—'}</p>
+      <input
+        onChange={() => notifyTyping()}
+        onBlur={() => stopTyping()}
+        onKeyDown={(e) => {
+          if (e.key === 'Enter') {
+            void send(e.currentTarget.value);
+            e.currentTarget.value = '';
+          }
+        }}
+      />
+    </div>
+  );
+}
+```
+
+## `<DotwireProvider>`
+
+```tsx
+<DotwireProvider options={dotwireOptions}>...</DotwireProvider>
+// or, if you already manage a DotwireClient yourself:
+<DotwireProvider client={existingClient}>...</DotwireProvider>
+```
+
+- Give it `options` (a `DotwireClientOptions`, same shape as `new DotwireClient(options)`) and
+  it constructs and disposes the client for you. Construction happens inside a `useEffect`, so
+  it is safe to render `DotwireProvider` on the server (`react-dom/server`) — nothing
+  browser-only runs during the render pass itself. Pass a stable `options` reference (e.g. a
+  module-level constant, or memoized with `useMemo`/`useState`) — a new object identity on
+  every render tears down and rebuilds the client.
+- Give it `client` instead and it never constructs or disposes anything — you own that
+  instance's lifecycle (including calling `client.dispose()` yourself).
+- `useDotwireClient()` returns `null` until the provider's effect has produced a client (always
+  the case during SSR, and briefly on first client-side render).
+
+## Hooks
+
+- **`useDotwireClient()`** → `DotwireClient | null`.
+  Use `client.room(roomId).getParticipants()` to fetch member IDs, then resolve names and avatars through the host app.
+- **`useConnectionState()`** → the client's live `ConnectionState`
+  (`'disconnected' | 'connecting' | 'connected' | 'reconnecting' | 'disconnecting'`).
+- **`useRoom(roomId, { history = 50 })`** → `{ messages, status, error, hasMore, loadOlder, send }`.
+  Subscribes for the lifetime of the component, loads the initial history page, and applies
+  live messages, retractions, and revocation. `messages` is always sorted by `seq` and deduped.
+  `status` starts `'connecting'`, becomes `'ready'` once the initial subscribe resolves,
+  `'revoked'` on membership revocation, or `'error'` if subscribe/send throws. `loadOlder()`
+  pages backwards with `beforeSeq` and prepends the results; `hasMore` reflects whether an
+  older page might still exist. `send(content)` wraps `sendMessage`.
+- **`useTyping(roomId)`** → `{ typingUsers, notifyTyping, stopTyping }`. A user drops out of
+  `typingUsers` either on an explicit "stopped typing" notification or after ~3.5s of silence
+  (time-based expiry, checked every second).
+- **`usePresence(roomId)`** → `{ present }`, accumulated from `joined`/`left` deltas since this
+  hook mounted. **There is no presence snapshot endpoint on the server** — a component that
+  mounts this hook after other members already joined will not see them in `present` until the
+  *next* delta for that room (the next join or leave).
+
+## Architecture
+
+All state transitions (new message, retraction, revocation, typing start/stop/expiry, presence
+deltas) live in pure, framework-free reducer functions in `src/reducers.ts` — each is unit
+tested directly with Node's test runner (`test/reducers.test.ts`), with no React or DOM
+involved. The hooks in `src/hooks.ts` are thin `useReducer` wrappers that wire the underlying
+`DotwireClient`/room event callbacks to `dispatch` calls.
+
+`useRoom`, `useTyping`, and `usePresence` can be mounted together for the same `roomId` (e.g. a
+message list plus a typing indicator). `DotwireClient.subscribe`/`unsubscribe` track hub-group
+membership per room without a refcount, so this package refcounts "leave the room" intent
+itself (`src/subscription.ts`) — the underlying hub group is only actually left once every hook
+watching that room has unmounted.
+
+There is a `react-dom/server` smoke test (`test/ssr.test.tsx`) asserting `DotwireProvider`
+renders without throwing when no browser APIs are available. Full DOM-based hook tests (e.g.
+with `jsdom`) are intentionally not included — add a DOM testing library of your choice if you
+want them.
+
+## License
+
+Apache-2.0

package/dist/index.cjs

@@ -0,0 +1,340 @@
+"use client";
+"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);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DotwireContext: () => DotwireContext,
+  DotwireProvider: () => DotwireProvider,
+  initialPresenceState: () => initialPresenceState,
+  initialRoomMessagesState: () => initialRoomMessagesState,
+  initialTypingState: () => initialTypingState,
+  presenceReducer: () => presenceReducer,
+  roomMessagesReducer: () => roomMessagesReducer,
+  typingReducer: () => typingReducer,
+  typingUsersOf: () => typingUsersOf,
+  useConnectionState: () => useConnectionState,
+  useDotwireClient: () => useDotwireClient,
+  usePresence: () => usePresence,
+  useRoom: () => useRoom,
+  useTyping: () => useTyping
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/provider.tsx
+var import_react = require("react");
+var import_client = require("@dotwire/client");
+var import_jsx_runtime = require("react/jsx-runtime");
+var DotwireContext = (0, import_react.createContext)(null);
+function DotwireProvider(props) {
+  const { children, options, client: providedClient } = props;
+  const [managedClient, setManagedClient] = (0, import_react.useState)(null);
+  (0, import_react.useEffect)(() => {
+    if (providedClient || !options) {
+      return void 0;
+    }
+    const instance = new import_client.DotwireClient(options);
+    setManagedClient(instance);
+    return () => {
+      instance.dispose();
+      setManagedClient((current) => current === instance ? null : current);
+    };
+  }, [providedClient, options]);
+  const client = providedClient ?? managedClient;
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(DotwireContext.Provider, { value: client, children });
+}
+
+// src/hooks.ts
+var import_react2 = require("react");
+
+// src/reducers.ts
+var initialRoomMessagesState = {
+  messages: [],
+  status: "connecting",
+  error: null,
+  hasMore: false
+};
+function mergeMessages(existing, incoming) {
+  if (incoming.length === 0) return existing;
+  const last = existing[existing.length - 1];
+  if (incoming.length === 1 && (last === void 0 || incoming[0].seq > last.seq)) return [...existing, incoming[0]];
+  const bySeq = /* @__PURE__ */ new Map();
+  for (const message of existing) bySeq.set(message.seq, message);
+  for (const message of incoming) bySeq.set(message.seq, message);
+  return Array.from(bySeq.values()).sort((a, b) => a.seq - b.seq);
+}
+function roomMessagesReducer(state, action) {
+  switch (action.type) {
+    case "reset":
+      return initialRoomMessagesState;
+    case "subscribed":
+      return {
+        messages: mergeMessages(state.messages, action.page.messages),
+        status: "ready",
+        error: null,
+        hasMore: action.page.hasMore
+      };
+    case "message":
+      return { ...state, messages: mergeMessages(state.messages, [action.message]) };
+    case "retracted":
+      return { ...state, messages: state.messages.filter((m) => m.seq !== action.seq) };
+    case "revoked":
+      return { ...state, status: "revoked" };
+    case "error":
+      return { ...state, status: "error", error: action.error };
+    case "olderLoaded":
+      return {
+        ...state,
+        messages: mergeMessages(state.messages, action.page.messages),
+        hasMore: action.page.hasMore
+      };
+    default:
+      return state;
+  }
+}
+var initialTypingState = {};
+function typingReducer(state, action) {
+  switch (action.type) {
+    case "notification": {
+      if (action.isTyping) {
+        return { ...state, [action.userId]: { updatedAt: action.now } };
+      }
+      if (!(action.userId in state)) return state;
+      const next = { ...state };
+      delete next[action.userId];
+      return next;
+    }
+    case "expire": {
+      let changed = false;
+      const next = {};
+      for (const [userId, entry] of Object.entries(state)) {
+        if (action.now - entry.updatedAt < action.ttlMs) {
+          next[userId] = entry;
+        } else {
+          changed = true;
+        }
+      }
+      return changed ? next : state;
+    }
+    default:
+      return state;
+  }
+}
+function typingUsersOf(state) {
+  return Object.keys(state);
+}
+var initialPresenceState = [];
+function presenceReducer(state, action) {
+  const set = new Set(state);
+  for (const id of action.left) set.delete(id);
+  for (const id of action.joined) set.add(id);
+  return Array.from(set).sort();
+}
+
+// src/subscription.ts
+var refCounts = /* @__PURE__ */ new WeakMap();
+function retainRoom(client, roomId) {
+  let rooms = refCounts.get(client);
+  if (!rooms) {
+    rooms = /* @__PURE__ */ new Map();
+    refCounts.set(client, rooms);
+  }
+  rooms.set(roomId, (rooms.get(roomId) ?? 0) + 1);
+}
+function releaseRoom(client, roomId) {
+  const rooms = refCounts.get(client);
+  if (!rooms) return true;
+  const next = (rooms.get(roomId) ?? 1) - 1;
+  if (next <= 0) {
+    rooms.delete(roomId);
+    return true;
+  }
+  rooms.set(roomId, next);
+  return false;
+}
+
+// src/hooks.ts
+function useDotwireClient() {
+  return (0, import_react2.useContext)(DotwireContext);
+}
+function useConnectionState() {
+  const client = useDotwireClient();
+  const [state, setState] = (0, import_react2.useState)(() => client?.getConnectionState() ?? "disconnected");
+  (0, import_react2.useEffect)(() => {
+    if (!client) {
+      setState("disconnected");
+      return void 0;
+    }
+    setState(client.getConnectionState());
+    return client.onStateChange(setState);
+  }, [client]);
+  return state;
+}
+function useRoom(roomId, options = {}) {
+  const history = options.history ?? 50;
+  const client = useDotwireClient();
+  const [state, dispatch] = (0, import_react2.useReducer)(roomMessagesReducer, initialRoomMessagesState);
+  const stateRef = (0, import_react2.useRef)(state);
+  stateRef.current = state;
+  const scopeRef = (0, import_react2.useRef)(null);
+  (0, import_react2.useEffect)(() => {
+    if (!client) return void 0;
+    const scope = {};
+    scopeRef.current = scope;
+    dispatch({ type: "reset" });
+    const room = client.room(roomId);
+    retainRoom(client, roomId);
+    let cancelled = false;
+    const unsubscribers = [
+      room.onMessage((message) => dispatch({ type: "message", message })),
+      room.onMessageRetracted(({ seq }) => dispatch({ type: "retracted", seq })),
+      room.onMembershipRevoked(() => dispatch({ type: "revoked" }))
+    ];
+    room.subscribe({ history }).then((page) => {
+      if (cancelled) return;
+      dispatch({ type: "subscribed", page: page ?? { messages: [], hasMore: false } });
+    }).catch((error) => {
+      if (!cancelled) dispatch({ type: "error", error });
+    });
+    return () => {
+      cancelled = true;
+      if (scopeRef.current === scope) scopeRef.current = null;
+      for (const unsub of unsubscribers) unsub();
+      room.release();
+      if (releaseRoom(client, roomId)) {
+        client.unsubscribe(roomId).catch(() => {
+        });
+      }
+    };
+  }, [client, roomId, history]);
+  const loadOlder = (0, import_react2.useCallback)(async () => {
+    if (!client) return;
+    const oldest = stateRef.current.messages[0];
+    if (!oldest) return;
+    const scope = scopeRef.current;
+    try {
+      const page = await client.getHistory(roomId, { beforeSeq: oldest.seq, limit: history });
+      if (scopeRef.current === scope) dispatch({ type: "olderLoaded", page });
+    } catch (error) {
+      if (scopeRef.current === scope) dispatch({ type: "error", error });
+    }
+  }, [client, roomId, history]);
+  const send = (0, import_react2.useCallback)(
+    async (content) => {
+      if (!client) {
+        throw new Error("Dotwire client is not ready yet.");
+      }
+      try {
+        return await client.sendMessage(roomId, content);
+      } catch (error) {
+        dispatch({ type: "error", error });
+        throw error;
+      }
+    },
+    [client, roomId]
+  );
+  return {
+    messages: state.messages,
+    status: state.status,
+    error: state.error,
+    hasMore: state.hasMore,
+    loadOlder,
+    send
+  };
+}
+var TYPING_EXPIRY_MS = 3500;
+var TYPING_EXPIRY_CHECK_INTERVAL_MS = 1e3;
+function useTyping(roomId) {
+  const client = useDotwireClient();
+  const [state, dispatch] = (0, import_react2.useReducer)(typingReducer, initialTypingState);
+  const roomHandleRef = (0, import_react2.useRef)(null);
+  (0, import_react2.useEffect)(() => {
+    if (!client) return void 0;
+    const room = client.room(roomId);
+    roomHandleRef.current = room;
+    retainRoom(client, roomId);
+    room.subscribe().catch(() => {
+    });
+    const unsub = room.onTyping((notification) => {
+      dispatch({ type: "notification", userId: notification.userId, isTyping: notification.isTyping, now: Date.now() });
+    });
+    const interval = setInterval(() => {
+      dispatch({ type: "expire", now: Date.now(), ttlMs: TYPING_EXPIRY_MS });
+    }, TYPING_EXPIRY_CHECK_INTERVAL_MS);
+    return () => {
+      unsub();
+      clearInterval(interval);
+      roomHandleRef.current = null;
+      room.release();
+      if (releaseRoom(client, roomId)) {
+        client.unsubscribe(roomId).catch(() => {
+        });
+      }
+    };
+  }, [client, roomId]);
+  const notifyTyping = (0, import_react2.useCallback)(async () => {
+    await roomHandleRef.current?.notifyTyping();
+  }, []);
+  const stopTyping = (0, import_react2.useCallback)(async () => {
+    await roomHandleRef.current?.stopTyping();
+  }, []);
+  return { typingUsers: typingUsersOf(state), notifyTyping, stopTyping };
+}
+function usePresence(roomId) {
+  const client = useDotwireClient();
+  const [state, dispatch] = (0, import_react2.useReducer)(presenceReducer, initialPresenceState);
+  (0, import_react2.useEffect)(() => {
+    if (!client) return void 0;
+    const room = client.room(roomId);
+    retainRoom(client, roomId);
+    room.subscribe().catch(() => {
+    });
+    const unsub = room.onPresence((delta) => {
+      dispatch({ type: "delta", joined: delta.joined, left: delta.left });
+    });
+    return () => {
+      unsub();
+      room.release();
+      if (releaseRoom(client, roomId)) {
+        client.unsubscribe(roomId).catch(() => {
+        });
+      }
+    };
+  }, [client, roomId]);
+  return { present: state };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DotwireContext,
+  DotwireProvider,
+  initialPresenceState,
+  initialRoomMessagesState,
+  initialTypingState,
+  presenceReducer,
+  roomMessagesReducer,
+  typingReducer,
+  typingUsersOf,
+  useConnectionState,
+  useDotwireClient,
+  usePresence,
+  useRoom,
+  useTyping
+});
+//# sourceMappingURL=index.cjs.map