chore: hook params alpha impl

src/hook.ts

@@ -1,22 +1,27 @@
 import React from 'react';
 import { collect, unsubscriber, run } from 'unsubscriber';
+import { signal, wrap, SignalReadonly } from './signal';
 
-export const hook = <T>(Class: (() => T) | (new () => T)): (() => T) => {
+export const hook = <T>(Class: ((params?: SignalReadonly<any>) => T) | (new (params?: SignalReadonly<any>) => T)): ((params?: any) => T) => {
 
-  return () => {
-    const [instance, unsubs] = React.useMemo(() => {
+  return (params: any) => {
+    const [instance, unsubs, signalParams] = React.useMemo(() => {
+      const signalParams = signal(params);
+      const wrapped = wrap(signalParams.get);
       const unsubs = unsubscriber();
       return [
         collect(unsubs, () => (
           Class.prototype === void 0
-            ? (Class as () => T)()
-            : new (Class as new () => T)()
+            ? (Class as (params?: SignalReadonly<any>) => T)(wrapped)
+            : new (Class as new (params?: SignalReadonly<any>) => T)(wrapped)
         )),
-        unsubs
+        unsubs,
+        signalParams
       ]
     }, []);
 
     React.useEffect(() => () => run(unsubs), [unsubs]);
+    signalParams(params);
     return instance;
   }
 }

src/index.ts

@@ -1,6 +1,6 @@
 export {
   type Signal,
-  type ReadonlySignal,
+  type SignalReadonly,
   signal,
   wrap
 } from './signal';

src/signal.ts

@@ -1,14 +1,14 @@
 import { observable, untracked, computed as mobxComputed, comparer } from 'mobx';
 import { reaction, sync } from './reaction';
 
-export interface ReadonlySignal<T> {
+export interface SignalReadonly<T> {
   get value(): T;
   get(): T;
   subscribe(listener: (current: T, prev: T) =>void): () => void;
   sync(listener: (current: T, prev: T | undefined) =>void): () => void;
 }
 
-export interface Signal<T> extends ReadonlySignal<T> {
+export interface Signal<T> extends SignalReadonly<T> {
   (value: T): T,
   update(fn: (value: T) => T);
 }
@@ -20,17 +20,17 @@ export function signal<T>(value: T): Signal<T> {
     return make(get, set);
 }
 
-export function wrap<T>(readfn: () => T): ReadonlySignal<T>;
+export function wrap<T>(readfn: () => T): SignalReadonly<T>;
 export function wrap<T>(readfn: () => T, writefn: (value: T) => void): Signal<T>;
-export function wrap<T>(readfn: () => T, writefn?: (value: T) => void): (ReadonlySignal<T> | Signal<T>) {
+export function wrap<T>(readfn: () => T, writefn?: (value: T) => void): (SignalReadonly<T> | Signal<T>) {
   const box = mobxComputed(readfn, { equals: comparer.shallow });
   const get = box.get.bind(box);
   return make(get, writefn);
 }
 
-function make<T>(readfn: () => T): ReadonlySignal<T>;
+function make<T>(readfn: () => T): SignalReadonly<T>;
 function make<T>(readfn: () => T, writefn: (value: T) => void): Signal<T>;
-function make<T>(readfn: () => T, writefn?: (value: T) => void): (ReadonlySignal<T> | Signal<T>) {
+function make<T>(readfn: () => T, writefn?: (value: T) => void): (SignalReadonly<T> | Signal<T>) {
     const get = readfn;
     const h = writefn || {};
     Object.defineProperty(h, 'value', { get })