signalium 0.3.1 → 0.3.3

package/src/__tests__/utils/instrumented-hooks.ts

@@ -7,8 +7,7 @@ import {
   watcher,
   SignalSubscribe,
   withContext,
-  clearRootScope,
-} from '../../hooks.js';
+} from '../../index.js';
 import { SignalOptionsWithInit, SignalSubscription, Watcher } from '../../types.js';
 
 class SignalHookCounts {

package/src/__tests__/utils/instrumented-signals.ts

@@ -124,7 +124,7 @@ expect.extend({
   },
 });
 
-export const createStateSignal = <T>(initialValue: T, opts?: SignalOptions<T>): WriteableSignal<T> => {
+export const createStateSignal = <T>(initialValue: T, opts?: SignalOptions<T, []>): WriteableSignal<T> => {
   const desc = opts?.desc || 'unlabeled';
   const s = _createStateSignal(initialValue, opts);
 
@@ -211,35 +211,45 @@ export const createSubscriptionSignal: typeof _createSubscriptionSignal = (subsc
   const desc = opts?.desc || 'unlabeled';
   const counts = new SignalCounts(desc);
 
-  const s = _createSubscriptionSignal((get, set) => {
+  const s = _createSubscriptionSignal(({ get, set }) => {
     counts.subscribe++;
 
     if (desc) {
       currentOrder?.push(desc);
     }
 
-    const result = subscribe(
-      () => {
+    const result = subscribe({
+      get: () => {
         counts.internalGet++;
         return get();
       },
-      v => {
+      set: v => {
         counts.internalSet++;
         set(v);
       },
-    );
+    });
 
-    const subscriptionWrapper: SignalSubscription = {
-      unsubscribe() {
+    let subscriptionWrapper: SignalSubscription | (() => unknown) | undefined;
+
+    if (typeof result === 'function') {
+      subscriptionWrapper = () => {
+        counts.unsubscribe++;
+        result();
+      };
+    } else {
+      subscriptionWrapper = {};
+
+      subscriptionWrapper.unsubscribe = () => {
         counts.unsubscribe++;
         result?.unsubscribe?.();
-      },
+      };
 
-      update() {
+      subscriptionWrapper.update = () => {
+        counts.compute++;
         counts.update++;
         result?.update?.();
-      },
-    };
+      };
+    }
 
     return subscriptionWrapper;
   }, opts);
@@ -256,7 +266,7 @@ export const createSubscriptionSignal: typeof _createSubscriptionSignal = (subsc
   return wrapper;
 };
 
-export function createWatcherSignal<T>(fn: () => T, opts?: SignalOptions<T>): Watcher<T> {
+export function createWatcherSignal<T>(fn: () => T, opts?: SignalOptions<T, []>): Watcher<T> {
   const desc = opts?.desc || 'unlabeled';
   const counts = new SignalCounts(desc);
 

package/src/__tests__/utils/permute.ts

@@ -26,12 +26,12 @@ const createMethods = [
       fn: (...args: Args) => T,
       opts?: Partial<SignalOptionsWithInit<T, Args>>,
     ): (...args: Args) => T {
-      return subscription(({ set }, ...args) => {
-        set(fn(...args));
+      return subscription((state, ...args) => {
+        state.set(fn(...args));
 
         return {
           update: () => {
-            set(fn(...args));
+            state.set(fn(...args));
           },
         };
       }, opts);

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 = (...args) => {
-                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(
-          () => {
-            const result = this.run(fn, args, 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,
@@ -400,7 +361,9 @@ export function subscription<T, Args extends unknown[]>(
 export const asyncTask = <T, Args extends unknown[]>(
   fn: (...args: Args) => Promise<T>,
   opts?: Partial<SignalOptionsWithInit<T, Args>>,
-): ((...args: Args) => AsyncTask<T>) => {
+): (<BuildArgs extends unknown[], RunArgs extends Args extends [...BuildArgs, ...infer _Rest] ? _Rest : Args>(
+  ...args: Args extends [...BuildArgs, ...infer _Rest] ? BuildArgs : Args
+) => AsyncTask<T, RunArgs>) => {
   return (...args) => {
     const params = getParamsKey(args, opts);
     const key = getComputedKey(fn, params);

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;
@@ -66,7 +71,7 @@ export interface AsyncReady<T> extends AsyncBaseResult<T> {
 
 export type AsyncResult<T> = AsyncPending<T> | AsyncReady<T>;
 
-export interface AsyncTask<T, Args extends unknown[] = unknown[]> {
+export interface AsyncTask<T, RunArgs extends unknown[] = unknown[]> {
   result: T | undefined;
   error: unknown;
   isPending: boolean;
@@ -74,7 +79,7 @@ export interface AsyncTask<T, Args extends unknown[] = unknown[]> {
   isError: boolean;
   isReady: boolean;
 
-  run(...args: Args): Promise<T>;
+  run(...args: RunArgs): Promise<T>;
 }
 
 export interface WatcherListenerOptions {