what-core 0.5.3 → 0.5.4

package/README.md

@@ -0,0 +1,119 @@
+# what-core
+
+The reactive engine behind [What Framework](https://whatfw.com). Provides signals, fine-grained reactivity, components, hooks, and DOM rendering -- all without a virtual DOM diffing step.
+
+Most users should install [`what-framework`](https://www.npmjs.com/package/what-framework) instead. `what-core` is the internal engine consumed by other What packages.
+
+## Install
+
+```bash
+npm install what-core
+```
+
+## Reactive Primitives
+
+```js
+import { signal, computed, effect, batch, untrack } from 'what-core';
+
+const count = signal(0);
+
+// Read
+count();          // 0
+
+// Write
+count.set(5);
+count.set(c => c + 1);
+
+// Derived value
+const doubled = computed(() => count() * 2);
+
+// Side effects
+effect(() => {
+  console.log('Count:', count());
+});
+
+// Batch updates (effects run once at the end)
+batch(() => {
+  a.set(1);
+  b.set(2);
+});
+
+// Read without subscribing
+untrack(() => someSignal());
+count.peek();
+```
+
+## Hooks
+
+React-compatible hooks backed by signals internally.
+
+```js
+import {
+  useState, useEffect, useMemo, useCallback,
+  useRef, useReducer, useContext, createContext,
+  onMount, onCleanup,
+} from 'what-core';
+
+const [count, setCount] = useState(0);
+
+useEffect(() => {
+  const id = setInterval(tick, 1000);
+  return () => clearInterval(id);
+}, []);
+```
+
+## Components
+
+```js
+import { h, mount, Fragment, memo, lazy, Suspense, ErrorBoundary, Show, For } from 'what-core';
+
+function Counter() {
+  const count = signal(0);
+  return h('button', { onclick: () => count.set(c => c + 1) }, () => count());
+}
+
+mount(h(Counter), '#app');
+```
+
+## Additional Modules
+
+| Export path | Contents |
+|---|---|
+| `what-core` | Signals, hooks, components, store, forms, data fetching, animation, a11y, skeleton loaders |
+| `what-core/render` | Fine-grained rendering primitives (`template`, `insert`, `spread`, `delegateEvents`) |
+| `what-core/jsx-runtime` | JSX automatic runtime |
+| `what-core/testing` | Test utilities |
+
+## API Overview
+
+**Reactivity** -- `signal`, `computed`, `effect`, `batch`, `untrack`, `flushSync`, `createRoot`
+
+**Rendering** -- `h`, `Fragment`, `html`, `mount`, `template`, `insert`, `spread`, `delegateEvents`
+
+**Hooks** -- `useState`, `useSignal`, `useComputed`, `useEffect`, `useMemo`, `useCallback`, `useRef`, `useContext`, `useReducer`, `createContext`, `onMount`, `onCleanup`, `createResource`
+
+**Components** -- `memo`, `lazy`, `Suspense`, `ErrorBoundary`, `Show`, `For`, `Switch`, `Match`, `Island`, `Portal`
+
+**Store** -- `createStore`, `derived`, `atom`
+
+**Data Fetching** -- `useSWR`, `useQuery`, `useInfiniteQuery`, `invalidateQueries`, `prefetchQuery`
+
+**Forms** -- `useForm`, `useField`, `rules`, `zodResolver`, `Input`, `Select`, `Checkbox`, `ErrorMessage`
+
+**Animation** -- `spring`, `tween`, `easings`, `useGesture`, `useTransition`
+
+**Accessibility** -- `useFocusTrap`, `FocusTrap`, `announce`, `SkipLink`, `useRovingTabIndex`, `VisuallyHidden`, `useId`
+
+**Scheduler** -- `scheduleRead`, `scheduleWrite`, `measure`, `mutate`, `onResize`, `onIntersect`
+
+**Head** -- `Head`, `clearHead`
+
+## Links
+
+- [Documentation](https://whatfw.com)
+- [GitHub](https://github.com/zvndev/what-fw)
+- [Benchmarks](https://benchmarks.whatfw.com)
+
+## License
+
+MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "what-core",
-  "version": "0.5.3",
+  "version": "0.5.4",
   "description": "What Framework - The closest framework to vanilla JS",
   "type": "module",
   "main": "dist/what.js",
@@ -53,5 +53,5 @@
   "bugs": {
     "url": "https://github.com/zvndev/what-fw/issues"
   },
-  "homepage": "https://whatframework.dev"
+  "homepage": "https://whatfw.com"
 }

package/src/data.js

@@ -636,3 +636,20 @@ export function clearCache() {
   lastFetchTimestamps.clear();
   inFlightRequests.clear();
 }
+
+/**
+ * Get a snapshot of all cache entries for devtools.
+ * @internal
+ */
+export function __getCacheSnapshot() {
+  const entries = [];
+  for (const [key, sig] of cacheSignals) {
+    entries.push({
+      key,
+      data: sig.peek(),
+      error: errorSignals.has(key) ? errorSignals.get(key).peek() : null,
+      isValidating: validatingSignals.has(key) ? validatingSignals.get(key).peek() : false,
+    });
+  }
+  return entries;
+}

package/src/dom.js

@@ -3,7 +3,7 @@
 // Components use <what-c> wrapper elements (display:contents) for clean reconciliation.
 // No virtual DOM tree kept in memory — we diff against the live DOM.
 
-import { effect, batch, untrack, signal } from './reactive.js';
+import { effect, batch, untrack, signal, __DEV__, __devtools } from './reactive.js';
 import { reportError, _injectGetCurrentComponent, shallowEqual } from './components.js';
 import { _setComponentRef } from './helpers.js';
 
@@ -97,6 +97,7 @@ function disposeComponent(ctx) {
     try { dispose(); } catch (e) { /* effect already disposed */ }
   }
 
+  if (__DEV__ && __devtools?.onComponentUnmount) __devtools.onComponentUnmount(ctx);
   mountedComponents.delete(ctx);
 }
 
@@ -304,6 +305,7 @@ function createComponent(vnode, parent, isSvg) {
 
   // Track for disposal
   mountedComponents.add(ctx);
+  if (__DEV__ && __devtools?.onComponentMount) __devtools.onComponentMount(ctx);
 
   // Props signal for reactive updates from parent
   // Match React's children semantics: 0→undefined, 1→single child, N→array

package/src/index.js

@@ -2,7 +2,7 @@
 // The closest framework to vanilla JS.
 
 // Reactive primitives
-export { signal, computed, effect, memo as signalMemo, batch, untrack, flushSync, createRoot } from './reactive.js';
+export { signal, computed, effect, memo as signalMemo, batch, untrack, flushSync, createRoot, __setDevToolsHooks } from './reactive.js';
 
 // Fine-grained rendering primitives
 export { template, insert, mapArray, spread, setProp, delegateEvents, on, classList } from './render.js';
@@ -132,6 +132,7 @@ export {
   setQueryData,
   getQueryData,
   clearCache,
+  __getCacheSnapshot,
 } from './data.js';
 
 // Form utilities

package/src/reactive.js

@@ -2,7 +2,9 @@
 // Signals + Effects: fine-grained reactivity without virtual DOM overhead
 
 // Dev-mode flag — build tools can dead-code-eliminate when false
-export const __DEV__ = typeof process !== 'undefined' && process.env?.NODE_ENV !== 'production' || true;
+export const __DEV__ = typeof process !== 'undefined'
+  ? process.env?.NODE_ENV !== 'production'
+  : true;
 
 // DevTools hooks — set by what-devtools when installed.
 // These are no-ops in production (dead-code eliminated with __DEV__).
@@ -22,7 +24,7 @@ let pendingEffects = [];
 // A reactive value. Reading inside an effect auto-tracks the dependency.
 // Writing triggers only the effects that depend on this signal.
 
-export function signal(initial) {
+export function signal(initial, debugName) {
   let value = initial;
   const subs = new Set();
 
@@ -59,6 +61,10 @@ export function signal(initial) {
   };
 
   sig._signal = true;
+  if (__DEV__) {
+    sig._subs = subs;
+    if (debugName) sig._debugName = debugName;
+  }
 
   // Notify devtools of signal creation
   if (__DEV__ && __devtools) __devtools.onSignalCreate(sig);
@@ -175,9 +181,13 @@ function _runEffect(e) {
     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);
     return;
   }
 
@@ -185,6 +195,7 @@ function _runEffect(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;
@@ -197,9 +208,13 @@ function _runEffect(e) {
     if (typeof result === 'function') {
       e._cleanup = result;
     }
+  } catch (err) {
+    if (__devtools?.onError) __devtools.onError(err, { type: 'effect', effect: e });
+    throw err;
   } finally {
     currentEffect = prev;
   }
+  if (__DEV__ && __devtools?.onEffectRun) __devtools.onEffectRun(e);
 }
 
 function _disposeEffect(e) {
@@ -238,6 +253,7 @@ function notify(subs) {
           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;