signalium 0.3.2 → 0.3.3

package/src/hooks.ts

@@ -19,6 +19,8 @@ import {
   SignalSubscription,
   Watcher,
   WriteableSignal,
+  SignalSubscribe,
+  SubscriptionState,
 } from './types.js';
 import { getObjectId, getUnknownSignalFnName, hashValue } from './utils.js';
 import { getFrameworkScope, useSignalValue } from './config.js';
@@ -172,40 +174,33 @@ export class SignalScope {
     let signal = this.getSignal(key, computedMask);
 
     if (signal === undefined) {
+      const optsWithMeta = { ...opts, id: key, desc: fnName, params };
       let initialized = false;
 
       if (makeSignal === createSubscriptionSignal) {
-        signal = makeSignal(
-          (get, set) => {
-            const sub = this.run(fn, [{ get, set }, ...args], key, signal!, initialized) as
-              | SignalSubscription
-              | undefined;
-
-            if (sub?.update) {
-              const originalUpdate = sub.update;
-
-              sub.update = () => {
-                return this.run(originalUpdate, [], key, signal!, initialized);
-              };
-            }
-
-            initialized = true;
-
-            return sub;
-          },
-          { ...opts, id: key, desc: fnName, params },
-        );
+        signal = makeSignal(state => {
+          const sub = this.run(fn, [state, ...args], key, signal!, initialized);
+
+          if (typeof sub === 'object' && sub !== null && sub?.update) {
+            const originalUpdate = sub.update;
+
+            sub.update = () => {
+              return this.run(originalUpdate, [], key, signal!, initialized);
+            };
+          }
+
+          initialized = true;
+
+          return sub;
+        }, optsWithMeta);
       } else {
-        signal = makeSignal(
-          (...runArgs) => {
-            const result = this.run(fn, [...args, ...runArgs], key, signal!, initialized);
+        signal = makeSignal((...runArgs) => {
+          const result = this.run(fn, [...args, ...runArgs], key, signal!, initialized);
 
-            initialized = true;
+          initialized = true;
 
-            return result;
-          },
-          { ...opts, id: key, desc: fnName, params },
-        );
+          return result;
+        }, optsWithMeta);
       }
     }
 
@@ -341,44 +336,10 @@ export function asyncComputed<T, Args extends unknown[]>(
   };
 }
 
-export interface SubscriptionState<T> {
-  get: () => T;
-  set: (value: T) => void;
-}
-
-export type SignalSubscribe<T, Args extends unknown[]> = (
-  state: SubscriptionState<T>,
-  ...args: Args
-) => SignalSubscription | (() => unknown) | undefined | void;
-
 export function subscription<T, Args extends unknown[]>(
   fn: SignalSubscribe<T, Args>,
   opts?: Partial<SignalOptionsWithInit<T, Args>>,
 ): (...args: Args) => T {
-  const wrapper = (state: SubscriptionState<T>, ...args: Args) => {
-    let result = fn(state, ...args);
-
-    if (typeof result === 'function') {
-      return {
-        update() {
-          (result as () => void)();
-          result = fn(state, ...args);
-        },
-
-        unsubscribe() {
-          (result as () => void)();
-        },
-      };
-    }
-
-    return result;
-  };
-
-  Object.defineProperty(wrapper, 'name', {
-    value: fn.name,
-    writable: false,
-  });
-
   return (...args) => {
     const params = getParamsKey(args, opts);
     const key = getComputedKey(fn, params);
@@ -387,7 +348,7 @@ export function subscription<T, Args extends unknown[]>(
       const scope = getCurrentScope();
       return scope.get(
         createSubscriptionSignal,
-        wrapper,
+        fn,
         key,
         params,
         args,

package/src/index.ts

@@ -13,6 +13,7 @@ export type {
   AsyncReady,
   AsyncResult,
   Watcher,
+  SubscriptionState,
 } from './types.js';
 
 export {
@@ -32,6 +33,7 @@ export {
   withContext,
   computed,
   asyncComputed,
+  asyncTask,
   subscription,
   watcher,
   SignalScope,

package/src/signals.ts

@@ -20,6 +20,7 @@ import {
   SignalOptionsWithInit,
   SignalSubscribe,
   SignalSubscription,
+  SubscriptionState,
   Watcher,
   WatcherListenerOptions,
 } from './types.js';
@@ -36,7 +37,7 @@ const enum SignalType {
   Watcher,
 }
 
-const SUBSCRIPTIONS = new WeakMap<ComputedSignal<any>, SignalSubscription | undefined | void>();
+const SUBSCRIPTIONS = new WeakMap<ComputedSignal<any>, SignalSubscription | (() => unknown) | undefined | void>();
 const ACTIVE_ASYNCS = new WeakMap<ComputedSignal<any>, Promise<unknown>>();
 
 const enum SignalState {
@@ -90,14 +91,14 @@ export class ComputedSignal<T> {
   _computedCount: number = 0;
   _connectedCount: number = 0;
   _currentValue: T | AsyncResult<T> | undefined;
-  _compute: SignalCompute<T> | SignalAsyncCompute<T> | SignalSubscribe<T>;
+  _compute: SignalCompute<T> | SignalAsyncCompute<T> | SignalSubscribe<T, []>;
 
   _opts: InternalSignalOptions<T>;
   _ref: WeakRef<ComputedSignal<T>> = new WeakRef(this);
 
   constructor(
     type: SignalType,
-    compute: SignalCompute<T> | SignalAsyncCompute<T> | SignalSubscribe<T>,
+    compute: SignalCompute<T> | SignalAsyncCompute<T> | SignalSubscribe<T, []>,
     opts: InternalSignalOptions<T>,
     initValue?: T,
   ) {
@@ -389,37 +390,18 @@ export class ComputedSignal<T> {
 
         case SignalType.Subscription: {
           if (shouldConnect) {
-            const subscription = (this._compute as SignalSubscribe<T>)(
-              () => this._currentValue as T,
-              value => {
-                const version = this._version;
-
-                if (version !== 0 && this._opts.equals(value, this._currentValue as T)) {
-                  return;
-                }
-
-                TRACER?.emit({
-                  type: TracerEventType.StartUpdate,
-                  id: this._opts.id,
-                });
-
-                this._currentValue = value;
-                this._version = version + 1;
-                this._dirtyConsumers();
-
-                TRACER?.emit({
-                  type: TracerEventType.EndUpdate,
-                  id: this._opts.id,
-                  value: this._currentValue,
-                  preserveChildren: true,
-                });
-              },
-            );
+            const subscription = (this._compute as SignalSubscribe<T, []>)(createSubscriptionState(this));
             SUBSCRIPTIONS.set(this, subscription);
           } else {
             const subscription = SUBSCRIPTIONS.get(this);
 
-            subscription?.update?.();
+            if (typeof subscription === 'function') {
+              subscription();
+              const nextSubscription = (this._compute as SignalSubscribe<T, []>)(createSubscriptionState(this));
+              SUBSCRIPTIONS.set(this, nextSubscription);
+            } else if (subscription !== undefined) {
+              subscription.update?.();
+            }
           }
 
           break;
@@ -552,7 +534,10 @@ export class ComputedSignal<T> {
     if (this._type === SignalType.Subscription) {
       const subscription = SUBSCRIPTIONS.get(this);
 
-      if (subscription !== undefined) {
+      if (typeof subscription === 'function') {
+        subscription();
+        SUBSCRIPTIONS.delete(this);
+      } else if (subscription !== undefined) {
         subscription.unsubscribe?.();
         SUBSCRIPTIONS.delete(this);
       }
@@ -596,6 +581,35 @@ export class ComputedSignal<T> {
   }
 }
 
+function createSubscriptionState<T>(signal: ComputedSignal<T>): SubscriptionState<T> {
+  return {
+    get: () => signal._currentValue as T,
+    set: value => {
+      const version = signal._version;
+
+      if (version !== 0 && signal._opts.equals(value, signal._currentValue as T)) {
+        return;
+      }
+
+      TRACER?.emit({
+        type: TracerEventType.StartUpdate,
+        id: signal._opts.id,
+      });
+
+      signal._currentValue = value;
+      signal._version = version + 1;
+      signal._dirtyConsumers();
+
+      TRACER?.emit({
+        type: TracerEventType.EndUpdate,
+        id: signal._opts.id,
+        value: signal._currentValue,
+        preserveChildren: true,
+      });
+    },
+  };
+}
+
 let STATE_ID = 0;
 
 export class StateSignal<T> implements StateSignal<T> {
@@ -703,15 +717,15 @@ export function createAsyncComputedSignal<T>(
 }
 
 export function createSubscriptionSignal<T>(
-  subscribe: SignalSubscribe<T>,
+  subscribe: SignalSubscribe<T, []>,
   opts?: SignalOptions<T, unknown[]>,
 ): Signal<T | undefined>;
 export function createSubscriptionSignal<T>(
-  subscribe: SignalSubscribe<T>,
+  subscribe: SignalSubscribe<T, []>,
   opts: SignalOptionsWithInit<T, unknown[]>,
 ): Signal<T>;
 export function createSubscriptionSignal<T>(
-  subscribe: SignalSubscribe<T>,
+  subscribe: SignalSubscribe<T, []>,
   opts?: Partial<SignalOptionsWithInit<T, unknown[]>>,
 ): Signal<T> {
   return new ComputedSignal(SignalType.Subscription, subscribe, normalizeOpts(opts), opts?.initValue) as Signal<T>;

package/src/types.ts

@@ -21,10 +21,15 @@ export type SignalSubscription = {
   unsubscribe?(): void;
 };
 
-export type SignalSubscribe<T> = (
-  get: () => T | undefined,
-  set: (value: T) => void,
-) => SignalSubscription | undefined | void;
+export interface SubscriptionState<T> {
+  get: () => T;
+  set: (value: T) => void;
+}
+
+export type SignalSubscribe<T, Args extends unknown[]> = (
+  state: SubscriptionState<T>,
+  ...args: Args
+) => SignalSubscription | (() => unknown) | undefined | void;
 
 export interface SignalOptions<T, Args extends unknown[]> {
   equals?: SignalEquals<T> | false;