update the code

Author: kethan

README.md

@@ -2,7 +2,7 @@
 
 [![tests](https://github.com/kethan/usub/actions/workflows/node.js.yml/badge.svg)](https://github.com/kethan/usub/actions/workflows/node.js.yml) [![Version](https://img.shields.io/npm/v/usub.svg?color=success&style=flat-square)](https://www.npmjs.com/package/usub) [![Badge size](https://deno.bundlejs.com/badge?q=usub&treeshake=[*]&config={"compression":"brotli"})](https://unpkg.com/usub) [![Badge size](https://deno.bundlejs.com/badge?q=usub&treeshake=[*]&config={"compression":"gzip"})](https://unpkg.com/usub)
 
-This JavaScript library provides utility functions for handling observables, signals, and asynchronous data streams across various reactive programming libraries. It supports flexible customization to integrate with different libraries, ensuring seamless subscription management and automatic cleanup.
+This javascript library provides utility functions for handling observables, signals, and asynchronous data streams across various reactive programming libraries. It supports flexible customization to integrate with different libraries, ensuring seamless subscription management and automatic cleanup.
 
 ## Table of Contents
 
@@ -18,9 +18,9 @@ This JavaScript library provides utility functions for handling observables, sig
     -   [Any Source](#any-source)
     -   [Solid.js](#solidjs)
     -   [Preact Signals](#preact-signals)
-    -   [uSignal](#usignal)
+    -   [usignal](#usignal)
     -   [@webreflection/signal](#webreflectionsignal)
-    -   [uLive](#ulive)
+    -   [ulive](#ulive)
     -   [RxJS Subject](#rxjs-subject)
     -   [Async Iterable](#async-iterable)
     -   [Synchronous Iterable](#synchronous-iterable)
@@ -50,18 +50,12 @@ import { is, api, sub, get } from "usub";
 
 ### Basic Setup
 
-The library exports three primary functions:
+The library exports four primary functions:
 
--   **`any`**: Add any type of source to react
 -   **`is`**: Checks if a value is considered an observable or reactive signal.
 -   **`api`**: Provides utility functions that can be customized to work with different reactive libraries.
 -   **`sub`**: Subscribes to an observable or other async/reactive patterns.
-
-Import the functions in your JavaScript file:
-
-```js
-import { is, api, sub } from "usub";
-```
+-   **`get`**: get function to retrieve reactive data
 
 ### Subscribing to Observables
 
@@ -345,9 +339,7 @@ const myIterable = {
 	},
 };
 
-for (const value of myIterable) {
-	console.log(value);
-}
+sub(myIterable)(console.log);
 ```
 
 ### Finalization and Cleanup

package-lock.json

@@ -1,22 +1,19 @@
 {
 	"name": "usub",
 	"description": "Subscribe to any reactive sources",
-	"version": "0.2.4",
+	"version": "0.3.0",
 	"type": "module",
 	"source": "./src/index.js",
 	"main": "./dist/index.js",
-	"module": "./dist/index.js",
+	"module": "./dist/index.es.js",
 	"unpkg": "./dist/index.min.js",
 	"umd:main": "./dist/index.umd.js",
 	"exports": {
-		".": {
-			"browser": "./dist/index.es.js",
-			"umd": "./dist/index.umd.js",
-			"require": "./dist/index.js",
-			"import": "./dist/index.es.js",
-			"default": "./dist/index.es.js"
-		},
-		"./package.json": "./package.json"
+		"browser": "./dist/index.es.js",
+		"umd": "./dist/index.umd.js",
+		"require": "./dist/index.js",
+		"import": "./dist/index.es.js",
+		"default": "./dist/index.es.js"
 	},
 	"repository": {
 		"type": "git",
@@ -27,22 +24,22 @@
 	],
 	"scripts": {
 		"build": "rollup --config rollup.config.js",
-		"test": "vitest",
-		"prepare": "husky"
+		"test": "node --allow-natives-syntax --loader ./test/https-loader.js --expose-gc ./test/index.js"
 	},
 	"devDependencies": {
 		"@rollup/plugin-terser": "^0.4.4",
-		"husky": "^9.1.4",
 		"rollup": "^4.20.0",
 		"rollup-plugin-bundle-size": "^1.0.3",
-		"vitest": "^2.0.5"
+		"tst": "^7.3.0"
 	},
 	"keywords": [
+		"rxjs",
 		"usub",
 		"reactive",
 		"state",
 		"signal",
 		"async",
+		"observable",
 		"observables",
 		"subscribe",
 		"effect",

package.json

@@ -1,13 +1,10 @@
 // Ensure the Symbol for observables is defined
 Symbol.observable ||= Symbol('observable');
 
-// FinalizationRegistry to clean up subscriptions when objects are garbage collected
 const
-    registry = new FinalizationRegistry((unsub) => {
-        if (!unsub?._) {
-            unsub?.call?.();
-        }
-    }),
+    // FinalizationRegistry to clean up subscriptions when objects are garbage collected
+    registry = new FinalizationRegistry(unsub => (!unsub?._ && unsub?.call?.())),
+
     // Utility function to handle unsubscription and complete callback
     unsubr = (unsub, cleanup, out) => (
         unsub && (out = () => (unsub?.call ? unsub() : unsub?.unsubscribe?.(), out._ = true, cleanup?.()))
@@ -22,37 +19,41 @@ const
         // Executes the provided function
         effect: (f) => f(),
         // Returns false for any value (placeholder implementation)
-        is: (v) => false,
+        is: (v) => v?.call,
         // Retrieves the value (returns it as is)
-        get: (v) => v,
+        get: (v) => v?.call(),
     },
 
-    // Utility function to handle and unwrap values, especially functions
-    get = (v) => v?.call ? get(v()) : api.is(v) ? get(api.get(v)) : v,
+    // Utility function to handle and unwrap values of signals, observable, etc especially functions
+    get = (v) => api.is(v) ? get(api.get(v)) : v?.call ? get(v()) : v,
 
     // Checks if the argument is considered an observable
     is = (arg) => arg && !!(
         arg[Symbol.observable] ||        // Observable symbol
         arg[Symbol.asyncIterator] ||     // Async iterator
+        arg[Symbol.iterator] ||          // Sync iterator
+        arg.call && arg.set ||           // Observ-*
         arg.then ||                      // Promise
-        (target?.call && !api?.any) ||                      // Function
         arg.subscribe ||                 // Observable with subscribe method
-        api.is(arg)                      // Custom observable check
+        api.is(arg) ||                   // Custom observable check
+        arg.call                        // Function
     ),
+    // Subscribe to an observable or value, and provide a callback for each value
     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.set && target.call?.(stop, next) ||
+        ((!api?.any && (api.is(target) || target?.call)) && api.effect(() => (next(get(target)), api?.cleanup?.(cleanup), cleanup))) ||
         (
             target.then?.(v => (!stop && next(get(v)), cleanup?.()), error) ||
-            target[Symbol.asyncIterator] && (async v => {
+            (target[Symbol.asyncIterator] || target[Symbol.iterator]) && (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)) }
                     cleanup?.()
                 } catch (err) { error?.(err) }
             })()
         ) && (_ => stop = 1) ||
-        (api?.any?.(target)?.(next, error, cleanup)),
+        (api?.any?.(target)?.(next, cleanup, error)),
         // register autocleanup
         registry.register(target, unsub),
         unsub

src/index.js

@@ -0,0 +1,47 @@
+// https-loader.mjs
+import { get } from 'https';
+
+export function resolve(specifier, context, defaultResolve) {
+    const { parentURL = null } = context;
+
+    // Normally Node.js would error on specifiers starting with 'https://', so
+    // this hook intercepts them and converts them into absolute URLs to be
+    // passed along to the later hooks below.
+    if (specifier.startsWith('https://')) {
+        return {
+            shortCircuit: true,
+            url: specifier
+        };
+    } else if (parentURL && parentURL.startsWith('https://')) {
+        return {
+            shortCircuit: true,
+            url: new URL(specifier, parentURL).href
+        };
+    }
+
+    // Let Node.js handle all other specifiers.
+    return defaultResolve(specifier, context, defaultResolve);
+}
+
+export async function load(url, context, defaultLoad) {
+    // For JavaScript to be loaded over the network, we need to fetch and
+    // return it.
+    if (url.startsWith('https://')) {
+        return await new Promise((resolve, reject) => {
+            get(url, (res) => {
+                let data = '';
+                res.on('data', (chunk) => data += chunk);
+                res.on('end', () => resolve({
+                    // This example assumes all network-provided JavaScript is ES module
+                    // code.
+                    shortCircuit: true,
+                    format: 'module',
+                    source: data,
+                }));
+            }).on('error', (err) => reject(err));
+        });
+    }
+
+    // Let Node.js handle all other URLs.
+    return defaultLoad(url, context, defaultLoad);
+}