npm package diff

Package: react-rx

Versions: 4.0.1 - 4.1.0-canary.5

File: package/dist/index.js

Index: package/dist/index.js
===================================================================
--- package/dist/index.js
+++ package/dist/index.js
@@ -1,62 +1,81 @@
-import { useMemo, useSyncExternalStore, useState, useEffect } from "react";
-import { catchError, of, finalize, share, timer, asapScheduler } from "rxjs";
+import { c } from "react-compiler-runtime";
+import { useSyncExternalStore, useState, useEffect } from "react";
+import { catchError, finalize, share, timer, asapScheduler, of } from "rxjs";
 import { map, tap } from "rxjs/operators";
 import { observableCallback } from "observable-callback";
 import { useEffectEvent } from "use-effect-event";
 function getValue(value) {
   return typeof value == "function" ? value() : value;
 }
 const cache = /* @__PURE__ */ new WeakMap();
 function useObservable(observable, initialValue) {
+  const $ = c(9);
   if (!cache.has(observable)) {
     const entry = {
       snapshot: getValue(initialValue)
     };
-    entry.observable = observable.pipe(
-      map((value) => ({ snapshot: value, error: void 0 })),
-      catchError((error) => of({ snapshot: void 0, error })),
-      tap(({ snapshot, error }) => {
-        entry.snapshot = snapshot, entry.error = error;
-      }),
-      // Note: any value or error emitted by the provided observable will be mapped to the cache entry's mutable state
-      // and the observable is thereafter only used as a notifier to call `onStoreChange`, hence the `void` return type.
-      map((value) => {
-      }),
-      // Ensure that the cache entry is deleted when the observable completes or errors.
-      finalize(() => cache.delete(observable)),
-      share({ resetOnRefCountZero: () => timer(0, asapScheduler) })
-    ), entry.observable.subscribe().unsubscribe(), cache.set(observable, entry);
+    entry.observable = observable.pipe(map(_temp$1), catchError(_temp2), tap((t02) => {
+      const {
+        snapshot,
+        error: error_0
+      } = t02;
+      entry.snapshot = snapshot, entry.error = error_0;
+    }), map(_temp3), finalize(() => cache.delete(observable)), share({
+      resetOnRefCountZero: _temp4
+    })), entry.observable.subscribe().unsubscribe(), cache.set(observable, entry);
   }
-  const store = useMemo(() => {
-    const instance = cache.get(observable);
-    return {
-      subscribe: (onStoreChange) => {
-        const subscription = instance.observable.subscribe(onStoreChange);
-        return () => {
-          subscription.unsubscribe();
-        };
-      },
-      getSnapshot: () => {
-        if (instance.error)
-          throw instance.error;
-        return instance.snapshot;
-      }
+  let t0;
+  $[0] !== observable ? (t0 = cache.get(observable), $[0] = observable, $[1] = t0) : t0 = $[1];
+  const instance = t0;
+  let t1;
+  $[2] !== instance.observable ? (t1 = (onStoreChange) => {
+    const subscription_0 = instance.observable.subscribe(onStoreChange);
+    return () => {
+      subscription_0.unsubscribe();
     };
-  }, [observable]);
-  return useSyncExternalStore(
-    store.subscribe,
-    store.getSnapshot,
-    typeof initialValue > "u" ? void 0 : () => getValue(initialValue)
-  );
+  }, $[2] = instance.observable, $[3] = t1) : t1 = $[3];
+  const subscribe = t1;
+  let t2;
+  $[4] !== instance.error || $[5] !== instance.snapshot ? (t2 = () => {
+    if (instance.error)
+      throw instance.error;
+    return instance.snapshot;
+  }, $[4] = instance.error, $[5] = instance.snapshot, $[6] = t2) : t2 = $[6];
+  let t3;
+  return $[7] !== initialValue ? (t3 = typeof initialValue > "u" ? void 0 : () => getValue(initialValue), $[7] = initialValue, $[8] = t3) : t3 = $[8], useSyncExternalStore(subscribe, t2, t3);
 }
+function _temp4() {
+  return timer(0, asapScheduler);
+}
+function _temp3(value_0) {
+}
+function _temp2(error) {
+  return of({
+    snapshot: void 0,
+    error
+  });
+}
+function _temp$1(value) {
+  return {
+    snapshot: value,
+    error: void 0
+  };
+}
 function useObservableEvent(handleEvent) {
-  const [[calls$, call]] = useState(() => observableCallback()), onEvent = useEffectEvent((observable) => handleEvent(observable));
-  return useEffect(() => {
-    const subscription = calls$.pipe((observable) => onEvent(observable)).subscribe();
+  const $ = c(6), [t0] = useState(_temp), [calls$, call] = t0;
+  let t1;
+  $[0] !== handleEvent ? (t1 = (observable) => handleEvent(observable), $[0] = handleEvent, $[1] = t1) : t1 = $[1];
+  const onEvent = useEffectEvent(t1);
+  let t2, t3;
+  return $[2] !== calls$ || $[3] !== onEvent ? (t2 = () => {
+    const subscription = calls$.pipe((observable_0) => onEvent(observable_0)).subscribe();
     return () => subscription.unsubscribe();
-  }, [calls$, onEvent]), call;
+  }, t3 = [calls$, onEvent], $[2] = calls$, $[3] = onEvent, $[4] = t2, $[5] = t3) : (t2 = $[4], t3 = $[5]), useEffect(t2, t3), call;
 }
+function _temp() {
+  return observableCallback();
+}
 export {
   useObservable,
   useObservableEvent
 };