atom.io 0.31.1 → 0.32.1

package/dist/chunk-KVI5OBF2.js

@@ -0,0 +1,153 @@
+import { myIdState__INTERNAL, pullAtom, pullAtomFamilyMember, pullMutableAtom, pullMutableAtomFamilyMember, pullSelector, pullSelectorFamilyMember, pushState, serverAction, syncContinuity } from './chunk-3ZFTRSNG.js';
+import { useI, StoreContext, useO } from './chunk-3PQTWLQQ.js';
+import { findInStore, actUponStore, arbitrary } from './chunk-UQEYZ3OI.js';
+import * as React from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+var RealtimeContext = React.createContext({
+  socket: null,
+  services: null
+});
+var RealtimeProvider = ({ children, socket }) => {
+  const services = React.useRef(/* @__PURE__ */ new Map()).current;
+  const setMyId = useI(myIdState__INTERNAL);
+  React.useEffect(() => {
+    setMyId(socket?.id);
+    socket?.on(`connect`, () => {
+      setMyId(socket.id);
+    });
+    socket?.on(`disconnect`, () => {
+      setMyId(void 0);
+    });
+  }, [socket, setMyId]);
+  return /* @__PURE__ */ jsx(RealtimeContext.Provider, { value: { socket, services }, children });
+};
+var { NODE_ENV } = globalThis.env ?? {};
+var IN_DEV = NODE_ENV === `development`;
+function noop() {
+}
+function useSingleEffect(effect, deps) {
+  if (IN_DEV) {
+    const cleanup = React.useRef(noop);
+    React.useEffect(() => {
+      let dispose = cleanup.current;
+      if (dispose === noop) {
+        dispose = effect() ?? noop;
+        cleanup.current = dispose;
+      } else {
+        return () => {
+          dispose();
+          cleanup.current = noop;
+        };
+      }
+    }, deps);
+  } else {
+    React.useEffect(effect, deps);
+  }
+}
+
+// realtime-react/src/on-mount.ts
+function onMount(effect) {
+  useSingleEffect(effect, []);
+}
+
+// realtime-react/src/use-realtime-service.ts
+function useRealtimeService(key, create) {
+  const { socket, services } = React.useContext(RealtimeContext);
+  onMount(() => {
+    let service = services?.get(key);
+    if (service) {
+      service[0]++;
+    } else {
+      const dispose = socket ? create(socket) : void 0;
+      service = [1, dispose];
+      services?.set(key, service);
+    }
+    return () => {
+      if (service) {
+        service[0]--;
+        if (service[0] === 0) {
+          service[1]?.();
+          services?.delete(key);
+        }
+      }
+    };
+  });
+}
+
+// realtime-react/src/use-pull-atom.ts
+function usePullAtom(token) {
+  const store = React.useContext(StoreContext);
+  useRealtimeService(
+    `pull:${token.key}`,
+    (socket) => pullAtom(store, socket, token)
+  );
+  return useO(token);
+}
+function usePullAtomFamilyMember(family, subKey) {
+  const store = React.useContext(StoreContext);
+  const token = findInStore(store, family, subKey);
+  useRealtimeService(
+    `pull:${token.key}`,
+    (socket) => pullAtomFamilyMember(store, socket, token)
+  );
+  return useO(token);
+}
+function usePullMutable(token) {
+  const store = React.useContext(StoreContext);
+  useRealtimeService(
+    `pull:${token.key}`,
+    (socket) => pullMutableAtom(store, socket, token)
+  );
+  return useO(token);
+}
+function usePullMutableAtomFamilyMember(familyToken, key) {
+  const store = React.useContext(StoreContext);
+  const token = findInStore(store, familyToken, key);
+  useRealtimeService(
+    `pull:${token.key}`,
+    (socket) => pullMutableAtomFamilyMember(store, socket, token)
+  );
+  return useO(token);
+}
+function usePullSelector(token) {
+  const store = React.useContext(StoreContext);
+  useRealtimeService(
+    `pull:${token.key}`,
+    (socket) => pullSelector(store, socket, token)
+  );
+  return useO(token);
+}
+function usePullSelectorFamilyMember(familyToken, key) {
+  const store = React.useContext(StoreContext);
+  const token = findInStore(store, familyToken, key);
+  useRealtimeService(
+    `pull:${token.key}`,
+    (socket) => pullSelectorFamilyMember(store, socket, token)
+  );
+  return useO(token);
+}
+function usePush(token) {
+  const store = React.useContext(StoreContext);
+  useRealtimeService(
+    `push:${token.key}`,
+    (socket) => pushState(store, socket, token)
+  );
+  return useI(token);
+}
+function useServerAction(token) {
+  const store = React.useContext(StoreContext);
+  useRealtimeService(
+    `tx:${token.key}`,
+    (socket) => serverAction(store, socket, token)
+  );
+  return actUponStore(store, token, arbitrary());
+}
+function useSyncContinuity(token) {
+  const store = React.useContext(StoreContext);
+  useRealtimeService(`tx-sync:${token.key}`, (socket) => {
+    return syncContinuity(store, socket, token);
+  });
+}
+
+export { RealtimeContext, RealtimeProvider, usePullAtom, usePullAtomFamilyMember, usePullMutable, usePullMutableAtomFamilyMember, usePullSelector, usePullSelectorFamilyMember, usePush, useServerAction, useSyncContinuity };