add api.cleanup for solid.js, sinuous,etc

Author: kethan

README.md

@@ -149,6 +149,10 @@ Defines how to check if a value is a signal or observable. This is where you ide
 
 Specifies how to retrieve the current value from a signal or observable. This function is where you define how to extract the current value from your reactive signal (e.g., v?.value or v?.()).
 
+-   **api.cleanup()**
+
+Provides a function to handle cleanup logic. This can be used to define any custom cleanup behavior required when a subscription is no longer needed.
+
 ### Example API Customization
 
 ### Any source
@@ -163,7 +167,7 @@ export let v =
 			? cb.splice.bind(cb, cb.push(c) - 1, 1, 0)
 			: cb.map((f) => f && f((v = c)));
 
-api.any = (target) => (next, error, complete) => target?.(v => next(v));
+api.any = (target) => (next, error, complete) => target?.((v) => next(v));
 
 const num = v(42);
 let off = sub(num)(console.log);
@@ -176,11 +180,12 @@ num(30);
 ### Solidjs
 
 ```js
-const { createSignal, createEffect } = require("solid-js");
+const { createSignal, createEffect, cleanup } = require("solid-js");
 
 api.effect = createEffect;
 api.is = (v) => v?.name?.includes("readSignal");
 api.get = (v) => v?.();
+api.cleanup = cleanup; //optional
 
 const [val, setVal] = createSignal(0);
 

package.json

@@ -1,7 +1,7 @@
 {
 	"name": "usub",
 	"description": "Subscribe to any reactive sources",
-	"version": "0.2.1",
+	"version": "0.2.2",
 	"type": "module",
 	"source": "./src/index.js",
 	"main": "./dist/index.js",

src/index.js

@@ -5,17 +5,20 @@ Symbol.observable ||= Symbol('observable');
 const
     registry = new FinalizationRegistry((unsub) => {
         if (!unsub?._) {
-            unsub.call?.();
+            unsub?.call?.();
         }
     }),
     // Utility function to handle unsubscription and complete callback
-    unsubr = (unsub, complete, out) => (
-        unsub && (out = () => (unsub?.call ? unsub() : unsub?.unsubscribe?.(), out._ = true, complete?.()))
+    unsubr = (unsub, cleanup, out) => (
+        unsub && (out = () => (unsub?.call ? unsub() : unsub?.unsubscribe?.(), out._ = true, cleanup?.()))
     ),
 
     // API object providing basic functions for handling effects and values
     api = {
+        // Handle any reactive subscription
         any: undefined,
+        // If any cleanup is requested
+        cleanup: undefined,
         // Executes the provided function
         effect: (f) => f(),
         // Returns false for any value (placeholder implementation)
@@ -32,33 +35,32 @@ const
         arg[Symbol.observable] ||        // Observable symbol
         arg[Symbol.asyncIterator] ||     // Async iterator
         arg.then ||                      // Promise
-        arg.call ||                      // Function
+        (target?.call && !api?.any) ||                      // Function
         arg.subscribe ||                 // Observable with subscribe method
         api.is(arg)                      // Custom observable check
     ),
-
-    sub = (target, stop, unsub) => (next, error, complete) => target && (
-        unsub = unsubr((target[Symbol.observable]?.() || target).subscribe?.((v) => next(get(v)), error, complete), complete) ||
-        ((target.call || api.is(target)) && api.effect(() => next(get(target)))) ||
+    sub = (target, stop, unsub) => (next, error, cleanup) => target && (
+        unsub = unsubr((target[Symbol.observable]?.() || target).subscribe?.((v) => next(get(v)), error, cleanup), cleanup) ||
+        (((target?.call && !api?.any) || api.is(target)) && api.effect(() => (next(get(target)), api?.cleanup?.(cleanup) || cleanup))) ||
         (
-            target.then?.(v => (!stop && next(get(v)), complete?.()), error) ||
+            target.then?.(v => (!stop && next(get(v)), cleanup?.()), error) ||
             target[Symbol.asyncIterator] && (async v => {
                 try {
                     // FIXME: possible drawback: it will catch error happened in next, not only in iterator
                     for await (v of target) { if (stop) return; next(get(v)) }
-                    complete?.()
+                    cleanup?.()
                 } catch (err) { error?.(err) }
             })()
         ) && (_ => stop = 1) ||
-        (api?.any?.(target)?.(next, error, complete)),
+        (api?.any?.(target)?.(next, error, cleanup)),
         // register autocleanup
         registry.register(target, unsub),
         unsub
     );
 
 export {
-    is,
     api,
+    is,
     sub,
     get
 }