what-core 0.6.7 → 0.6.9

package/hooks.d.ts

@@ -1,25 +1,26 @@
 // What Framework - Hooks Type Definitions
 
-import { Signal } from './index.js';
+import { Signal, Computed, Updater, VNodeChild } from './index.js';
 
-export function useState<T>(initial: T | (() => T)): [Signal<T>, (value: T | ((prev: T) => T)) => void];
-export function useSignal<T>(initial: T): Signal<T>;
-export function useComputed<T>(fn: () => T): Signal<T>;
+export function useState<T>(initial: T | (() => T)): [Signal<T>, (value: Updater<T>) => void];
+export function useSignal<T>(initial: T | (() => T)): Signal<T>;
+export function useComputed<T>(fn: () => T): Computed<T>;
 export function useEffect(fn: () => void | (() => void), deps?: any[]): void;
-export function useMemo<T>(fn: () => T, deps?: any[]): T;
+export function useMemo<T>(fn: () => T, deps?: any[]): Computed<T>;
 export function useCallback<T extends (...args: any[]) => any>(fn: T, deps?: any[]): T;
-export function useRef<T>(initial?: T): { current: T };
+export function useRef<T>(initial?: T): { current: T | undefined };
 export function useContext<T>(context: { _defaultValue: T }): T;
-export function createContext<T>(defaultValue?: T): { _defaultValue: T; Provider: (props: { value: T; children: any }) => any };
+export function createContext<T>(defaultValue?: T): { _defaultValue: T; Provider: (props: { value: T; children?: VNodeChild }) => VNodeChild; Consumer: (props: { children: (value: T) => VNodeChild }) => VNodeChild };
 export function useReducer<S, A>(reducer: (state: S, action: A) => S, initialState: S, init?: (s: S) => S): [Signal<S>, (action: A) => void];
 export function onMount(fn: () => void | (() => void)): void;
 export function onCleanup(fn: () => void): void;
 
-export interface Resource<T> {
-  (): T | undefined;
+export function createResource<T = any, S = any>(
+  fetcher: (source?: S, ctx?: { signal: AbortSignal }) => Promise<T> | T,
+  options?: { initialValue?: T; source?: S },
+): [Signal<T | null>, {
   loading: Signal<boolean>;
-  error: Signal<Error | null>;
-  refetch: () => void;
-  mutate: (value: T) => void;
-}
-export function createResource<T>(fetcher: () => Promise<T>, options?: { initialValue?: T }): Resource<T>;
+  error: Signal<any>;
+  refetch: (source?: S) => Promise<any>;
+  mutate: (value: Updater<T | null>) => void;
+}];

package/index.d.ts

@@ -130,11 +130,11 @@ export function classList(el: Element, classes: Record<string, boolean | (() =>
 
 // --- Hooks ---
 
-export function useState<T>(initial: T | (() => T)): [T, (value: Updater<T>) => void];
+export function useState<T>(initial: T | (() => T)): [Signal<T>, (value: Updater<T>) => void];
 export function useSignal<T>(initial: T | (() => T)): Signal<T>;
 export function useComputed<T>(fn: () => T): Computed<T>;
 export function useEffect(fn: () => void | (() => void), deps?: unknown[]): void;
-export function useMemo<T>(fn: () => T, deps?: unknown[]): T;
+export function useMemo<T>(fn: () => T, deps?: unknown[]): Computed<T>;
 export function useCallback<T extends (...args: any[]) => any>(fn: T, deps?: unknown[]): T;
 export function useRef<T>(initial: T): { current: T };
 
@@ -149,7 +149,7 @@ export function useReducer<S, A>(
   reducer: (state: S, action: A) => S,
   initialState: S,
   init?: (initial: S) => S,
-): [S, (action: A) => void];
+): [Signal<S>, (action: A) => void];
 export function onMount(fn: () => void): void;
 export function onCleanup(fn: () => void): void;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "what-core",
-  "version": "0.6.7",
+  "version": "0.6.9",
   "description": "What Framework - The closest framework to vanilla JS",
   "type": "module",
   "main": "src/index.js",
@@ -73,7 +73,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/CelsianJs/what-framework"
+    "url": "git+https://github.com/CelsianJs/what-framework.git"
   },
   "bugs": {
     "url": "https://github.com/CelsianJs/what-framework/issues"

package/src/dom.js

@@ -589,28 +589,8 @@ function applyProps(el, newProps, oldProps, isSvg) {
 }
 
 function setProp(el, key, value, isSvg) {
-  // Sanitize URL attributes before property assignment or setAttribute can commit them.
-  if (!isSafeUrlAttributeValue(key, value)) {
-    if (typeof console !== 'undefined') {
-      console.warn(`[what] Blocked unsafe URL in "${key}" attribute: ${value}`);
-    }
-    el.removeAttribute(getDomAttributeName(key));
-    return;
-  }
-  // Reactive function props — wrap in effect for fine-grained updates
-  if (typeof value === 'function' && !(key.startsWith('on') && key.length > 2) && key !== 'ref') {
-    if (!el._propEffects) el._propEffects = {};
-    if (el._propEffects[key]) {
-      try { el._propEffects[key](); } catch (e) { /* already disposed */ }
-    }
-    el._propEffects[key] = effect(() => {
-      const resolved = value();
-      setProp(el, key, resolved, isSvg);
-    });
-    return;
-  }
-
-  // Event handlers
+  // Event handlers are not URL-bearing attributes; keep this fast path ahead of
+  // URL sanitization so hot event mount paths do not pay attr normalization costs.
   if (key.startsWith('on') && key.length > 2) {
     let eventName = key.slice(2);
     let useCapture = false;
@@ -636,6 +616,35 @@ function setProp(el, key, value, isSvg) {
     return;
   }
 
+  // Refs are object/function assignments, not DOM URL sinks. Keep them out of
+  // URL sanitization when setProp is reached directly by reactive updates.
+  if (key === 'ref') {
+    if (typeof value === 'function') value(el);
+    else if (value) value.current = el;
+    return;
+  }
+
+  // Sanitize URL attributes before property assignment or setAttribute can commit them.
+  if (!isSafeUrlAttributeValue(key, value)) {
+    if (typeof console !== 'undefined') {
+      console.warn(`[what] Blocked unsafe URL in "${key}" attribute: ${value}`);
+    }
+    el.removeAttribute(getDomAttributeName(key));
+    return;
+  }
+  // Reactive function props — wrap in effect for fine-grained updates
+  if (typeof value === 'function') {
+    if (!el._propEffects) el._propEffects = {};
+    if (el._propEffects[key]) {
+      try { el._propEffects[key](); } catch (e) { /* already disposed */ }
+    }
+    el._propEffects[key] = effect(() => {
+      const resolved = value();
+      setProp(el, key, resolved, isSvg);
+    });
+    return;
+  }
+
   // className / class
   if (key === 'className' || key === 'class') {
     if (isSvg) {

package/src/index.js

@@ -15,12 +15,16 @@ export { h, Fragment, html } from './h.js';
 // DOM mounting & rendering (fine-grained, no VDOM reconciler)
 export { mount } from './dom.js';
 
-// Hooks — Solid-style API (signal-first)
-// React-style hooks (useState, useEffect, useMemo, useCallback, useRef)
-// are available via 'what-framework/react-compat' only.
+// Hooks — run-once component hooks backed by signals.
+// useState returns a signal accessor plus setter; useMemo returns a computed signal.
 export {
+  useState,
   useSignal,
   useComputed,
+  useEffect,
+  useMemo,
+  useCallback,
+  useRef,
   useContext,
   useReducer,
   createContext,

package/src/reactive.js

@@ -323,36 +323,13 @@ function _runEffect(e) {
 
   // Stable effect fast path: deps don't change, skip cleanup/re-subscribe.
   if (e._stable) {
-    if (e._cleanup) {
-      try { e._cleanup(); } catch (err) {
-        if (__DEV__) console.warn('[what] Error in effect cleanup:', err);
-      }
-      e._cleanup = null;
-    }
-    const prev = currentEffect;
-    currentEffect = null; // Don't re-track deps (already subscribed)
-    try {
-      const result = e.fn();
-      if (typeof result === 'function') e._cleanup = result;
-    } catch (err) {
-      if (__devtools?.onError) __devtools.onError(err, { type: 'effect', effect: e });
-      if (__DEV__) console.warn('[what] Error in stable effect:', err);
-    } finally {
-      currentEffect = prev;
-    }
-    if (__DEV__ && __devtools?.onEffectRun) __devtools.onEffectRun(e);
+    runStableEffect(e);
     return;
   }
 
   cleanup(e);
   // Run effect cleanup from previous run
-  if (e._cleanup) {
-    try { e._cleanup(); } catch (err) {
-      if (__devtools?.onError) __devtools.onError(err, { type: 'effect-cleanup', effect: e });
-      if (__DEV__) console.warn('[what] Error in effect cleanup:', err);
-    }
-    e._cleanup = null;
-  }
+  runEffectCleanup(e, 'effect cleanup');
   const prev = currentEffect;
   currentEffect = e;
   try {
@@ -376,14 +353,41 @@ function _disposeEffect(e) {
   if (__DEV__ && __devtools) __devtools.onEffectDispose(e);
   cleanup(e);
   // Run cleanup on dispose
-  if (e._cleanup) {
-    try { e._cleanup(); } catch (err) {
-      if (__DEV__) console.warn('[what] Error in effect cleanup on dispose:', err);
-    }
-    e._cleanup = null;
+  runEffectCleanup(e, 'effect cleanup on dispose');
+}
+
+function reportEffectCleanupError(err, e, phase) {
+  if (__devtools?.onError) __devtools.onError(err, { type: 'effect-cleanup', effect: e, phase });
+  if (__DEV__) console.warn(`[what] Error in ${phase}:`, err);
+}
+
+function runEffectCleanup(e, phase) {
+  if (!e._cleanup) return;
+  const cleanupFn = e._cleanup;
+  e._cleanup = null;
+  try {
+    cleanupFn();
+  } catch (err) {
+    reportEffectCleanupError(err, e, phase);
   }
 }
 
+function runStableEffect(e) {
+  const prev = currentEffect;
+  currentEffect = null; // Don't re-track deps (already subscribed)
+  try {
+    runEffectCleanup(e, 'stable effect cleanup');
+    const result = e.fn();
+    if (typeof result === 'function') e._cleanup = result;
+  } catch (err) {
+    if (__devtools?.onError) __devtools.onError(err, { type: 'effect', effect: e });
+    if (__DEV__) console.warn('[what] Error in stable effect:', err);
+  } finally {
+    currentEffect = prev;
+  }
+  if (__DEV__ && __devtools?.onEffectRun) __devtools.onEffectRun(e);
+}
+
 function cleanup(e) {
   const deps = e.deps;
   for (let i = 0; i < deps.length; i++) deps[i].delete(e);
@@ -413,21 +417,7 @@ function notify(subs) {
           // _onNotify may call notify() recursively — tracked by notifyDepth.
           e._onNotify();
         } else if (batchDepth === 0 && e._stable) {
-          // Inline execution for stable effects
-          const prev = currentEffect;
-          currentEffect = null;
-          try {
-            const result = e.fn();
-            if (typeof result === 'function') {
-              if (e._cleanup) try { e._cleanup(); } catch (err) {}
-              e._cleanup = result;
-            }
-          } catch (err) {
-            if (__devtools?.onError) __devtools.onError(err, { type: 'effect', effect: e });
-            if (__DEV__) console.warn('[what] Error in stable effect:', err);
-          } finally {
-            currentEffect = prev;
-          }
+          runStableEffect(e);
         } else if (!e._pending) {
           e._pending = true;
           const level = e._level;
@@ -450,20 +440,7 @@ function notify(subs) {
             if (e._onNotify) {
               e._onNotify();
             } else if (batchDepth === 0 && e._stable) {
-              const prev = currentEffect;
-              currentEffect = null;
-              try {
-                const result = e.fn();
-                if (typeof result === 'function') {
-                  if (e._cleanup) try { e._cleanup(); } catch (err) {}
-                  e._cleanup = result;
-                }
-              } catch (err) {
-                if (__devtools?.onError) __devtools.onError(err, { type: 'effect', effect: e });
-                if (__DEV__) console.warn('[what] Error in stable effect:', err);
-              } finally {
-                currentEffect = prev;
-              }
+              runStableEffect(e);
             } else if (!e._pending) {
               e._pending = true;
               const level = e._level;