applesauce-react 0.0.0-next-20250923113611 → 0.0.0-next-20251203172109

package/dist/hooks/use-event-factory.d.ts

@@ -1,4 +1,4 @@
-import { EventFactory } from "applesauce-factory";
+import { EventFactory } from "applesauce-core";
 export declare function useEventFactory(require: false): EventFactory | undefined;
 export declare function useEventFactory(require: true): EventFactory;
 export declare function useEventFactory(): EventFactory;

package/dist/hooks/use-observable-memo.js

@@ -1,6 +1,7 @@
-import { useObservableEagerState, useObservableState } from "observable-hooks";
+import { useObservableEagerState } from "observable-hooks";
 import { useMemo } from "react";
 import { of } from "rxjs";
+import { useObservableState } from "./use-observable-state.js";
 export function useObservableMemo(factory, deps) {
     return useObservableState(useMemo(() => factory() || of(undefined), deps));
 }

package/dist/hooks/use-observable-state.d.ts

@@ -0,0 +1,20 @@
+import { BehaviorSubject, Observable } from "rxjs";
+/**
+ * A hook that subscribes to an Observable and returns its current value.
+ *
+ * Unlike the standard `useObservableState` from observable-hooks, this hook
+ * will synchronously get the initial value if the Observable emits synchronously.
+ * This prevents an extra render when the Observable has an immediate value.
+ *
+ * If the Observable does not emit synchronously, the hook returns `undefined`
+ * for the initial render (unlike `useObservableEagerState` which throws).
+ *
+ * The observable is only subscribed to once - the subscription created during
+ * the initial probe is kept alive and reused, avoiding issues with cold observables.
+ *
+ * @template TState State type.
+ * @param state$ An Observable of state values.
+ * @returns The current state value, or `undefined` if no value has been emitted yet.
+ */
+export declare function useObservableState<TState>(state$: BehaviorSubject<TState>): TState;
+export declare function useObservableState<TState>(state$: Observable<TState>): TState | undefined;

package/dist/hooks/use-observable-state.js

@@ -0,0 +1,107 @@
+import { useDebugValue, useEffect, useLayoutEffect, useRef, useState } from "react";
+import { useForceUpdate } from "observable-hooks";
+// Prevent React warning when using useLayoutEffect on server
+const useIsomorphicLayoutEffect = typeof window === "undefined" ? useEffect : useLayoutEffect;
+// Symbol to indicate no value was emitted
+const NO_VALUE = Symbol("NO_VALUE");
+function createSubscription(observable) {
+    const subState = {
+        observable,
+        subscription: null,
+        latestValue: NO_VALUE,
+        latestError: null,
+        onValue: null,
+        onError: null,
+    };
+    subState.subscription = observable.subscribe({
+        next: (value) => {
+            subState.latestValue = value;
+            subState.onValue?.(value);
+        },
+        error: (error) => {
+            subState.latestError = error;
+            subState.onError?.();
+        },
+    });
+    return subState;
+}
+export function useObservableState(state$) {
+    const forceUpdate = useForceUpdate();
+    // Ref to hold the subscription state - persists across renders
+    const subStateRef = useRef(null);
+    // Initialize state - this only runs once per component instance
+    const [state, setState] = useState(() => {
+        // Clean up any existing subscription (shouldn't happen in useState init, but be safe)
+        if (subStateRef.current) {
+            subStateRef.current.subscription.unsubscribe();
+        }
+        // Create subscription and probe for sync value
+        const subState = createSubscription(state$);
+        subStateRef.current = subState;
+        // Return sync value if available
+        return subState.latestValue !== NO_VALUE ? subState.latestValue : undefined;
+    });
+    // Track current observable for staleness checks
+    const state$Ref = useRef(state$);
+    useIsomorphicLayoutEffect(() => {
+        state$Ref.current = state$;
+    });
+    // Handle observable changes and register callbacks
+    useEffect(() => {
+        let subState = subStateRef.current;
+        // If observable changed, create new subscription
+        if (!subState || subState.observable !== state$) {
+            // Clean up old subscription
+            subState?.subscription.unsubscribe();
+            // Create new subscription
+            subState = createSubscription(state$);
+            subStateRef.current = subState;
+            // Update state if we got a sync value from new observable
+            if (subState.latestValue !== NO_VALUE) {
+                setState(subState.latestValue);
+            }
+            else {
+                setState(undefined);
+            }
+        }
+        else {
+            // Same observable - check if we missed any values between useState and useEffect
+            if (subState.latestValue !== NO_VALUE && subState.latestValue !== state) {
+                setState(subState.latestValue);
+            }
+        }
+        // Check for errors that occurred before useEffect
+        if (subState.latestError !== null) {
+            forceUpdate();
+        }
+        // Register callbacks for future emissions
+        subState.onValue = (value) => {
+            if (state$Ref.current === state$) {
+                setState(value);
+            }
+        };
+        subState.onError = () => {
+            if (state$Ref.current === state$) {
+                forceUpdate();
+            }
+        };
+        return () => {
+            // Unregister callbacks
+            subState.onValue = null;
+            subState.onError = null;
+            // Unsubscribe
+            subState.subscription.unsubscribe();
+            // Clear the ref if this is still the current subscription
+            if (subStateRef.current === subState) {
+                subStateRef.current = null;
+            }
+        };
+    }, [state$]);
+    // Throw errors to be caught by error boundary
+    const subState = subStateRef.current;
+    if (subState?.latestError !== null && subState?.observable === state$) {
+        throw subState.latestError;
+    }
+    useDebugValue(state);
+    return state;
+}

package/dist/hooks/use-observable.d.ts

@@ -1 +1,2 @@
-export * from "observable-hooks";
+export { useObservableCallback, useSubscription, useObservableEagerState, useObservableGetState, useObservablePickState, useObservableSuspense, useForceUpdate, } from "observable-hooks";
+export { useObservableState } from "./use-observable-state.js";

package/dist/hooks/use-observable.js

@@ -1,2 +1,5 @@
 // NOTE: re-export hooks from observable-hooks to avoid confusion
-export * from "observable-hooks";
+// We override useObservableState with our own implementation that gets sync values
+export { useObservableCallback, useSubscription, useObservableEagerState, useObservableGetState, useObservablePickState, useObservableSuspense, useForceUpdate, } from "observable-hooks";
+// Export our custom useObservableState that gets sync values
+export { useObservableState } from "./use-observable-state.js";

package/dist/hooks/use-rendered-content.d.ts

@@ -1,7 +1,7 @@
 import { getParsedContent } from "applesauce-content/text";
-import { EventTemplate, NostrEvent } from "nostr-tools";
-import { ComponentMap } from "../helpers/nast.js";
+import { EventTemplate, NostrEvent } from "applesauce-core/helpers/event";
 import { LinkRenderer } from "../helpers/build-link-renderer.js";
+import { ComponentMap } from "../helpers/nast.js";
 export { ComponentMap };
 type Options = {
     /** The key to cache the results under, passing null will disable */

package/dist/hooks/use-rendered-content.js

@@ -1,8 +1,8 @@
-import { useMemo } from "react";
 import { truncateContent } from "applesauce-content/nast";
 import { getParsedContent } from "applesauce-content/text";
-import { useRenderNast } from "./use-render-nast.js";
+import { useMemo } from "react";
 import { buildLinkRenderer } from "../helpers/build-link-renderer.js";
+import { useRenderNast } from "./use-render-nast.js";
 /** Returns the parsed and render text content for an event */
 export function useRenderedContent(event, components, opts) {
     // if link renderers are set, override the link components

package/dist/providers/factory-provider.d.ts

@@ -1,4 +1,4 @@
-import { EventFactory } from "applesauce-factory";
+import { EventFactory } from "applesauce-core";
 import { PropsWithChildren } from "react";
 export declare const FactoryContext: import("react").Context<EventFactory | undefined>;
 /** Provides an {@link EventFactory} to the component tree */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-react",
-  "version": "0.0.0-next-20250923113611",
+  "version": "0.0.0-next-20251203172109",
   "description": "React hooks for applesauce",
   "type": "module",
   "main": "dist/index.js",
@@ -48,13 +48,11 @@
     }
   },
   "dependencies": {
-    "applesauce-accounts": "0.0.0-next-20250923113611",
-    "applesauce-actions": "0.0.0-next-20250923113611",
-    "applesauce-content": "0.0.0-next-20250923113611",
-    "applesauce-core": "0.0.0-next-20250923113611",
-    "applesauce-factory": "0.0.0-next-20250923113611",
+    "applesauce-accounts": "0.0.0-next-20251203172109",
+    "applesauce-actions": "0.0.0-next-20251203172109",
+    "applesauce-content": "0.0.0-next-20251203172109",
+    "applesauce-core": "0.0.0-next-20251203172109",
     "hash-sum": "^2.0.0",
-    "nostr-tools": "~2.17",
     "observable-hooks": "^4.2.4",
     "react": "^18.3.1",
     "rxjs": "^7.8.1"
@@ -64,7 +62,7 @@
     "@types/react": "^18.3.18",
     "rimraf": "^6.0.1",
     "typescript": "^5.8.3",
-    "vitest": "^3.2.4"
+    "vitest": "^4.0.15"
   },
   "funding": {
     "type": "lightning",