fix: pumped to next version of submodule

Author: Duke

bun.lockb

@@ -7,7 +7,7 @@
     "react": "^18.0.0 || ^19.0.0"
   },
   "peerDependencies": {
-    "@submodule/core": "^11.2.0",
+    "@submodule/core": "^11.3.1",
     "react": "^18.0.0 || ^19.0.0"
   },
   "tsup": {
@@ -49,7 +49,7 @@
   },
   "devDependencies": {
     "@testing-library/react": "^16.1.0",
-    "@submodule/core": "^11.2.0",
+    "@submodule/core": "^11.3.1",
     "tsup": "^8.3.5",
     "typescript": "^5.7.2",
     "vitest": "^2.1.8"

package.json

@@ -3,9 +3,7 @@ import {
 	type Executor,
 	type Scope,
 	type ObservableGet,
-	provideObservable,
 	combineObservables,
-	combine,
 } from "@submodule/core";
 
 import React, {
@@ -83,8 +81,9 @@ let cache = [] as CacheEntry[];
 /**
  * Core functionality of submodule. Resolves an executor within the current scope.
  *
- * @param executor
- * @returns
+ * @param executor - The executor to resolve within the current scope.
+ * @returns The resolved value of the executor.
+ * @throws {Promise} If the executor is not yet resolved, a promise is thrown to suspend the component.
  */
 export function useResolve<T>(executor: Executor<T>): T {
 	const scope = useContext(scopeContext);
@@ -122,33 +121,33 @@ export function useResolve<T>(executor: Executor<T>): T {
 	throw cacheEntry[2].promise;
 }
 
-export function useObservable<P, V>(
+/**
+ * Subscribes to an observable and returns its current value.
+ * Optionally transforms the value using the provided transform function.
+ *
+ * @param executor - The executor to resolve the observable.
+ * @param transform - Optional transform function to apply to the observable value.
+ * @param params - Additional parameters to pass to the transform function.
+ * @returns The current value of the observable, optionally transformed.
+ */
+export function useObservable<P, V, Params extends Array<unknown>>(
 	executor: Executor<ObservableGet<P>>,
-	transform: (value: P) => V,
+	transform: (value: P, ...params: Params) => V,
+	...params: Params
 ): V;
 
 export function useObservable<P>(executor: Executor<ObservableGet<P>>): P;
 
-/**
- * Subscribes to an Observable and returns its current value.
- * Uses Suspense for loading states.
- *
- * @template P The payload type
- * @template API The controller API type
- * @param executor The Observable instance
- * @returns The current value of the Observable
- * @throws {Promise} During initial load (for Suspense)
- * @throws {Error} If used outside of a ScopeProvider
- */
-export function useObservable<P, V>(
+export function useObservable<P, V, Params extends Array<unknown>>(
 	executor: Executor<ObservableGet<P>>,
-	transform?: (value: P) => V,
+	transform?: (nextvalue: P, ...params: Params) => V,
+	...params: Params
 ): P | V {
 	const observable = useResolve(executor);
 
 	const subs = useCallback(
 		(cb: () => void) => {
-			return observable.onValue((next) => {
+			return observable.onValue(() => {
 				queueMicrotask(cb);
 			});
 		},
@@ -157,11 +156,38 @@ export function useObservable<P, V>(
 
 	return useSyncExternalStore(
 		subs,
-		() => (transform ? transform(observable.value) : observable.value),
-		() => (transform ? transform(observable.value) : observable.value),
+		() =>
+			transform ? transform(observable.value, ...params) : observable.value,
+		() =>
+			transform ? transform(observable.value, ...params) : observable.value,
 	);
 }
 
+/**
+ * An utility hook to wrap a transform function inside a useCallback. Supposed to use with useObservable.
+ * @param transform Specifies the transform function to use
+ * @param params Additional params can be added
+ * @returns function that wrapped inside useCallback
+ */
+export function useTransformFn<P, V, Params extends Array<unknown>>(
+	transform: (nextValue: P, ...params: Params) => V,
+	...params: Params
+): (value: P, ...params: Params) => V {
+	return useCallback(
+		(value: P, ...params: Params) => transform(value, ...params),
+		[transform, ...params],
+	);
+}
+
+/**
+ * Combines multiple observables into a single value.
+ * Optionally transforms the combined value using the provided transform function.
+ *
+ * @param upstreams - An object containing the executors for the observables to combine.
+ * @param transform - Optional transform function to apply to the combined value.
+ * @param initialValue - Optional initial value for the combined value.
+ * @returns The combined value of the observables, optionally transformed.
+ */
 export function useCombines<Upstreams extends Record<string, unknown>, Value>(
 	upstreams: {
 		[K in keyof Upstreams]: Executor<ObservableGet<Upstreams[K]>>;