what-core 0.1.0

package/dist/store.js

@@ -0,0 +1,59 @@
+import { signal, computed, batch } from './reactive.js';
+export function createStore(definition) {
+const signals = {};
+const computeds = {};
+const actions = {};
+const state = {};
+for (const [key, value] of Object.entries(definition)) {
+if (typeof value === 'function' && value.length > 0 && key !== 'constructor') {
+computeds[key] = value;
+} else if (typeof value === 'function') {
+actions[key] = value;
+} else {
+signals[key] = signal(value);
+}
+}
+for (const [key, fn] of Object.entries(computeds)) {
+const proxy = new Proxy({}, {
+get(_, prop) {
+if (signals[prop]) return signals[prop]();
+if (computeds[prop]) return computeds[prop]();
+return undefined;
+},
+});
+computeds[key] = computed(() => fn(proxy));
+}
+for (const [key, fn] of Object.entries(actions)) {
+actions[key] = (...args) => {
+batch(() => {
+const proxy = new Proxy({}, {
+get(_, prop) {
+if (signals[prop]) return signals[prop].peek();
+return undefined;
+},
+set(_, prop, val) {
+if (signals[prop]) signals[prop].set(val);
+return true;
+},
+});
+fn.apply(proxy, args);
+});
+};
+}
+return function useStore() {
+const result = {};
+for (const [key, s] of Object.entries(signals)) {
+Object.defineProperty(result, key, { get: () => s(), enumerable: true });
+}
+for (const [key, c] of Object.entries(computeds)) {
+Object.defineProperty(result, key, { get: () => c(), enumerable: true });
+}
+for (const [key, fn] of Object.entries(actions)) {
+result[key] = fn;
+}
+return result;
+};
+}
+export function atom(initial) {
+return signal(initial);
+}

package/dist/what.js

@@ -0,0 +1,114 @@
+export { signal, computed, effect, batch, untrack } from './reactive.js';
+export { h, Fragment, html } from './h.js';
+export { mount } from './dom.js';
+export {
+useState,
+useSignal,
+useComputed,
+useEffect,
+useMemo,
+useCallback,
+useRef,
+useContext,
+useReducer,
+createContext,
+onMount,
+onCleanup,
+createResource,
+} from './hooks.js';
+export { memo, lazy, Suspense, ErrorBoundary, Show, For, Switch, Match } from './components.js';
+export { createStore, atom } from './store.js';
+export { Head, clearHead } from './head.js';
+export {
+show,
+each,
+cls,
+style,
+debounce,
+throttle,
+useMediaQuery,
+useLocalStorage,
+Portal,
+transition,
+} from './helpers.js';
+export {
+scheduleRead,
+scheduleWrite,
+flushScheduler,
+measure,
+mutate,
+useScheduledEffect,
+nextFrame,
+raf,
+onResize,
+onIntersect,
+smoothScrollTo,
+} from './scheduler.js';
+export {
+spring,
+tween,
+easings,
+useTransition,
+useGesture,
+useAnimatedValue,
+createTransitionClasses,
+cssTransition,
+} from './animation.js';
+export {
+useFocus,
+useFocusTrap,
+FocusTrap,
+announce,
+announceAssertive,
+SkipLink,
+useAriaExpanded,
+useAriaSelected,
+useAriaChecked,
+useRovingTabIndex,
+VisuallyHidden,
+LiveRegion,
+useId,
+useIds,
+useDescribedBy,
+useLabelledBy,
+Keys,
+onKey,
+onKeys,
+} from './a11y.js';
+export {
+Skeleton,
+SkeletonText,
+SkeletonAvatar,
+SkeletonCard,
+SkeletonTable,
+IslandSkeleton,
+useSkeleton,
+Placeholder,
+LoadingDots,
+Spinner,
+} from './skeleton.js';
+export {
+useFetch,
+useSWR,
+useQuery,
+useInfiniteQuery,
+invalidateQueries,
+prefetchQuery,
+setQueryData,
+getQueryData,
+clearCache,
+} from './data.js';
+export {
+useForm,
+useField,
+rules,
+simpleResolver,
+zodResolver,
+yupResolver,
+Input,
+Textarea,
+Select,
+Checkbox,
+Radio,
+ErrorMessage,
+} from './form.js';

package/index.d.ts

@@ -0,0 +1,252 @@
+// What Framework - TypeScript Definitions
+
+// --- Reactive Primitives ---
+
+/** A reactive value container */
+export interface Signal<T> {
+  /** Read the current value (tracks dependency if inside effect) */
+  (): T;
+  /** Update the value */
+  set(value: T | ((prev: T) => T)): void;
+  /** Read without tracking */
+  peek(): T;
+  /** Subscribe to changes */
+  subscribe(fn: (value: T) => void): () => void;
+  /** Internal marker */
+  _signal: true;
+}
+
+/** Create a reactive signal */
+export function signal<T>(initial: T): Signal<T>;
+
+/** A derived reactive value (lazy evaluation) */
+export interface Computed<T> {
+  (): T;
+  peek(): T;
+  _signal: true;
+}
+
+/** Create a computed signal */
+export function computed<T>(fn: () => T): Computed<T>;
+
+/** Create a side effect that re-runs when dependencies change */
+export function effect(fn: () => void | (() => void)): () => void;
+
+/** Batch multiple signal updates into one flush */
+export function batch<T>(fn: () => T): T;
+
+/** Read signals without subscribing */
+export function untrack<T>(fn: () => T): T;
+
+// --- Virtual DOM ---
+
+export interface VNode<P = any> {
+  tag: string | Component<P>;
+  props: P;
+  children: VNodeChild[];
+  key: string | number | null;
+  _vnode: true;
+}
+
+export type VNodeChild = VNode | string | number | boolean | null | undefined | VNodeChild[];
+
+export type Component<P = {}> = (props: P & { children?: VNodeChild }) => VNode | VNodeChild;
+
+/** Create a virtual DOM node */
+export function h<P extends {}>(
+  tag: string | Component<P>,
+  props?: P | null,
+  ...children: VNodeChild[]
+): VNode<P>;
+
+/** Fragment component */
+export function Fragment(props: { children?: VNodeChild }): VNodeChild;
+
+/** Tagged template for JSX-like syntax without build step */
+export function html(strings: TemplateStringsArray, ...values: any[]): VNode | VNode[];
+
+// --- DOM Mounting ---
+
+/** Mount a VNode tree into a container */
+export function mount(vnode: VNode, container: string | Element): () => void;
+
+// --- Hooks ---
+
+/** State hook - returns [value, setter] */
+export function useState<T>(initial: T | (() => T)): [T, (value: T | ((prev: T) => T)) => void];
+
+/** Signal hook - returns raw signal */
+export function useSignal<T>(initial: T | (() => T)): Signal<T>;
+
+/** Computed hook */
+export function useComputed<T>(fn: () => T): Computed<T>;
+
+/** Effect hook with optional dependencies */
+export function useEffect(fn: () => void | (() => void), deps?: any[]): void;
+
+/** Memoized value hook */
+export function useMemo<T>(fn: () => T, deps: any[]): T;
+
+/** Memoized callback hook */
+export function useCallback<T extends (...args: any[]) => any>(fn: T, deps: any[]): T;
+
+/** Ref hook */
+export function useRef<T>(initial: T): { current: T };
+
+/** Context hook */
+export function useContext<T>(context: Context<T>): T;
+
+/** Reducer hook */
+export function useReducer<S, A>(
+  reducer: (state: S, action: A) => S,
+  initialState: S,
+  init?: (initial: S) => S
+): [S, (action: A) => void];
+
+/** Create a context */
+export interface Context<T> {
+  _value: T;
+  Provider: Component<{ value: T; children?: VNodeChild }>;
+}
+
+export function createContext<T>(defaultValue: T): Context<T>;
+
+// --- Component Utilities ---
+
+/** Skip re-render if props are equal */
+export function memo<P>(
+  component: Component<P>,
+  areEqual?: (prev: P, next: P) => boolean
+): Component<P>;
+
+/** Lazy-load a component */
+export function lazy<P>(
+  loader: () => Promise<{ default: Component<P> } | Component<P>>
+): Component<P>;
+
+/** Suspense boundary for lazy components */
+export function Suspense(props: {
+  fallback: VNodeChild;
+  children?: VNodeChild;
+}): VNode;
+
+/** Error boundary for catching component errors */
+export function ErrorBoundary(props: {
+  fallback: VNodeChild | ((props: { error: Error; reset: () => void }) => VNodeChild);
+  onError?: (error: Error) => void;
+  children?: VNodeChild;
+}): VNode;
+
+// --- Store ---
+
+export interface StoreDefinition {
+  [key: string]: any;
+}
+
+export type Store<T extends StoreDefinition> = {
+  [K in keyof T]: T[K] extends (...args: any[]) => any ? T[K] : T[K];
+};
+
+/** Create a global reactive store */
+export function createStore<T extends StoreDefinition>(definition: T): () => Store<T>;
+
+/** Create a simple global atom */
+export function atom<T>(initial: T): Signal<T>;
+
+// --- Utilities ---
+
+/** Conditional rendering helper */
+export function show<T extends VNodeChild>(condition: boolean, vnode: T, fallback?: VNodeChild): T | VNodeChild;
+
+/** List rendering helper with optional key function */
+export function each<T>(
+  list: T[],
+  fn: (item: T, index: number) => VNode,
+  keyFn?: (item: T, index: number) => string | number
+): VNode[];
+
+/** Conditional class names */
+export function cls(...args: (string | false | null | undefined | Record<string, boolean>)[]): string;
+
+/** Convert style object to string */
+export function style(obj: string | Record<string, string | number | null | undefined>): string;
+
+/** Debounce a function */
+export function debounce<T extends (...args: any[]) => any>(fn: T, ms: number): T;
+
+/** Throttle a function */
+export function throttle<T extends (...args: any[]) => any>(fn: T, ms: number): T;
+
+/** Reactive media query */
+export function useMediaQuery(query: string): Signal<boolean>;
+
+/** Signal synced with localStorage */
+export function useLocalStorage<T>(key: string, initial: T): Signal<T>;
+
+/** Render children in a different DOM container */
+export function Portal(props: { target: string | Element; children?: VNodeChild }): VNode | null;
+
+/** CSS transition helper */
+export function transition(name: string, active: boolean): { class: string };
+
+// --- Head Management ---
+
+/** Manage document head */
+export function Head(props: {
+  title?: string;
+  meta?: Record<string, string>[];
+  link?: Record<string, string>[];
+  script?: Record<string, string>[];
+  children?: VNodeChild;
+}): null;
+
+/** Clear managed head elements */
+export function clearHead(): void;
+
+// --- DOM Scheduler ---
+
+/** Schedule a DOM read operation */
+export function scheduleRead(fn: () => void): () => void;
+
+/** Schedule a DOM write operation */
+export function scheduleWrite(fn: () => void): () => void;
+
+/** Flush all pending scheduler operations */
+export function flushScheduler(): void;
+
+/** Measure DOM (returns promise) */
+export function measure<T>(fn: () => T): Promise<T>;
+
+/** Mutate DOM (returns promise) */
+export function mutate(fn: () => void): Promise<void>;
+
+/** Effect that batches DOM operations */
+export function useScheduledEffect(
+  readFn: () => any,
+  writeFn?: (data: any) => void
+): () => void;
+
+/** Returns promise that resolves on next animation frame */
+export function nextFrame(): Promise<void> & { cancel: () => void };
+
+/** Debounced requestAnimationFrame */
+export function raf(key: string, fn: () => void): void;
+
+/** Observe element resize */
+export function onResize(
+  element: Element,
+  callback: (rect: DOMRectReadOnly) => void
+): () => void;
+
+/** Observe element intersection */
+export function onIntersect(
+  element: Element,
+  callback: (entry: IntersectionObserverEntry) => void,
+  options?: IntersectionObserverInit
+): () => void;
+
+/** Smooth scroll to element */
+export function smoothScrollTo(
+  element: Element,
+  options?: { duration?: number; easing?: (t: number) => number }
+): Promise<void>;

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "what-core",
+  "version": "0.1.0",
+  "description": "What Framework - The closest framework to vanilla JS",
+  "type": "module",
+  "main": "dist/what.js",
+  "module": "src/index.js",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./src/index.js",
+      "require": "./dist/what.cjs"
+    },
+    "./testing": {
+      "types": "./testing.d.ts",
+      "import": "./src/testing.js"
+    }
+  },
+  "files": [
+    "src",
+    "dist",
+    "index.d.ts",
+    "testing.d.ts"
+  ],
+  "sideEffects": false,
+  "keywords": [
+    "framework",
+    "signals",
+    "reactive",
+    "islands",
+    "ssr",
+    "vanilla-js",
+    "lightweight",
+    "vdom"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aspect/what-fw"
+  },
+  "bugs": {
+    "url": "https://github.com/aspect/what-fw/issues"
+  },
+  "homepage": "https://github.com/aspect/what-fw#readme"
+}