atom.io 0.31.1 → 0.32.0

package/dist/chunk-354XQWHH.js

@@ -0,0 +1,153 @@
+import { myIdState__INTERNAL, pullAtom, pullAtomFamilyMember, pullMutableAtom, pullMutableAtomFamilyMember, pullSelector, pullSelectorFamilyMember, pushState, serverAction, syncContinuity } from './chunk-Z2UJW4NQ.js';
+import { useI, StoreContext, useO } from './chunk-5F2V7S3B.js';
+import { findInStore, actUponStore, arbitrary } from './chunk-GY2XQYZY.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(undefined);
+    });
+  }, [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) : undefined;
+      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 };

package/dist/chunk-4LWKCEW3.js

@@ -0,0 +1,14 @@
+// web/src/persist-sync.ts
+var persistSync = (storage, { stringify, parse }, key) => ({ setSelf, onSet }) => {
+  const savedValue = storage.getItem(key);
+  if (savedValue != null) setSelf(parse(savedValue));
+  onSet(({ newValue }) => {
+    if (newValue == null) {
+      storage.removeItem(key);
+      return;
+    }
+    storage.setItem(key, stringify(newValue));
+  });
+};
+
+export { persistSync };

package/dist/chunk-5F2V7S3B.js

@@ -0,0 +1,83 @@
+import { IMPLICIT, setIntoStore, subscribeToState, getFromStore, findInStore, getJsonToken, withdraw, subscribeToTimeline, undo, redo } from './chunk-GY2XQYZY.js';
+import * as React5 from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+var StoreContext = React5.createContext(IMPLICIT.STORE);
+var StoreProvider = ({ children, store = IMPLICIT.STORE }) => /* @__PURE__ */ jsx(StoreContext.Provider, { value: store, children });
+
+// react/src/parse-state-overloads.ts
+function parseStateOverloads(store, ...rest) {
+  let token;
+  if (rest.length === 2) {
+    const family = rest[0];
+    const key = rest[1];
+    token = findInStore(store, family, key);
+  } else {
+    token = rest[0];
+  }
+  return token;
+}
+
+// react/src/use-i.ts
+function useI(...params) {
+  const store = React5.useContext(StoreContext);
+  const token = parseStateOverloads(store, ...params);
+  const setter = React5.useRef(null);
+  if (setter.current === null) {
+    setter.current = (next) => {
+      setIntoStore(store, token, next);
+    };
+  }
+  return setter.current;
+}
+function useO(...params) {
+  const store = React5.useContext(StoreContext);
+  const token = parseStateOverloads(store, ...params);
+  const id = React5.useId();
+  return React5.useSyncExternalStore(
+    (dispatch) => subscribeToState(store, token, `use-o:${id}`, dispatch),
+    () => getFromStore(store, token),
+    () => getFromStore(store, token)
+  );
+}
+
+// react/src/use-json.ts
+function useJSON(token, key) {
+  const store = React5.useContext(StoreContext);
+  const stateToken = token.type === `mutable_atom_family` ? findInStore(store, token, key) : token;
+  const jsonToken = getJsonToken(store, stateToken);
+  return useO(jsonToken);
+}
+function useTL(token) {
+  const store = React5.useContext(StoreContext);
+  const id = React5.useId();
+  const timeline = withdraw(store, token);
+  const tokenRef = React5.useRef(token);
+  const rebuildMeta = () => {
+    return {
+      at: timeline.at,
+      length: timeline.history.length,
+      undo: () => {
+        undo(token);
+      },
+      redo: () => {
+        redo(token);
+      }
+    };
+  };
+  const meta = React5.useRef(rebuildMeta());
+  const retrieve = () => {
+    if (meta.current.at !== timeline?.at || meta.current.length !== timeline?.history.length || tokenRef.current !== token) {
+      tokenRef.current = token;
+      meta.current = rebuildMeta();
+    }
+    return meta.current;
+  };
+  return React5.useSyncExternalStore(
+    (dispatch) => subscribeToTimeline(store, token, `use-tl:${id}`, dispatch),
+    retrieve,
+    retrieve
+  );
+}
+
+export { StoreContext, StoreProvider, useI, useJSON, useO, useTL };