@rectify-dev/core 2.0.1 → 2.0.3

package/dist/index.d.cts

@@ -1,8 +1,24 @@
-import { FC } from '@rectify-dev/shared';
+import { RectifyNode, FC, Fiber } from '@rectify-dev/shared';
 export { AnchorHTMLAttributes, AriaAttributes, AudioHTMLAttributes, ButtonHTMLAttributes, CSSProperties, FC, FormHTMLAttributes, HTMLAttributes, IframeHTMLAttributes, ImgHTMLAttributes, InputHTMLAttributes, LabelHTMLAttributes, MetaHTMLAttributes, OptGroupHTMLAttributes, OptionHTMLAttributes, RectifyEventHandlers, RectifyIntrinsicElements, ScriptHTMLAttributes, SelectHTMLAttributes, SyntheticAnimationEvent, SyntheticChangeEvent, SyntheticClipboardEvent, SyntheticDragEvent, SyntheticEvent as SyntheticEventType, SyntheticFocusEvent, SyntheticInputEvent, SyntheticKeyboardEvent, SyntheticMouseEvent, SyntheticPointerEvent, SyntheticSubmitEvent, SyntheticTouchEvent, SyntheticTransitionEvent, SyntheticWheelEvent, TextareaHTMLAttributes, VideoHTMLAttributes } from '@rectify-dev/shared';
-export { SyntheticEvent, createRoot } from '@rectify-dev/dom';
 export { Fragment, jsx } from './runtime.cjs';
-export { RectifyContext, RefObject, createContext, useCallback, useContext, useEffect, useLayoutEffect, useMemo, useRef, useState } from '@rectify-dev/hook';
+
+type RectifyDomRoot = {
+    render: (node: RectifyNode) => void;
+    unmount: () => void;
+};
+declare const createRoot: (container: Element) => RectifyDomRoot;
+
+type AnyNativeEvent = Event | KeyboardEvent | MouseEvent | TouchEvent;
+
+declare class SyntheticEvent {
+    target: Element | null;
+    currentTarget: Element | null;
+    nativeEvent: AnyNativeEvent;
+    private propagationStopped;
+    constructor(nativeEvent: AnyNativeEvent);
+    stopPropagation(): void;
+    isPropagationStopped(): boolean;
+}
 
 type MemoComponent<P = any> = FC<P> & {
     /** Marks this as a memo-wrapped component for the reconciler. */
@@ -28,4 +44,117 @@ type MemoComponent<P = any> = FC<P> & {
  */
 declare function memo<P = any>(Component: FC<P>, compare?: (prevProps: P, nextProps: P) => boolean): MemoComponent<P>;
 
-export { type MemoComponent, memo };
+type StateUpdater<S> = S | ((prevState: S) => S);
+type StateDispatcher<S> = (updater: StateUpdater<S>) => void;
+
+declare function useState<S>(): [S | undefined, StateDispatcher<S | undefined>];
+declare function useState<S>(initialState: S): [S, StateDispatcher<S>];
+declare function useState<S>(initialState: () => S): [S, StateDispatcher<S>];
+
+declare function useEffect(create: () => void | (() => void), deps?: any[]): void;
+
+/**
+ * Like `useEffect`, but fires **synchronously after every DOM mutation** and
+ * before the browser has a chance to paint.  Use this when you need to read
+ * layout or synchronously re-style the DOM (tooltips, scroll restoration,
+ * measuring element sizes, etc.).
+ *
+ * Prefer `useEffect` for everything else — `useLayoutEffect` blocks the paint.
+ *
+ * @example
+ * useLayoutEffect(() => {
+ *   const { height } = ref.current.getBoundingClientRect();
+ *   setTooltipTop(-height);
+ * }, []);
+ */
+declare function useLayoutEffect(create: () => void | (() => void), deps?: any[]): void;
+
+type RefObject<T> = {
+    current: T;
+};
+/**
+ * Returns a stable mutable ref object whose `.current` property is initialised
+ * to `initialValue`.  The same object is returned on every render — updating
+ * `.current` does NOT trigger a re-render.
+ *
+ * Two common uses:
+ *   1. Hold a DOM node:   const el = useRef<HTMLDivElement>(null)
+ *   2. Hold a mutable value across renders without causing re-renders.
+ */
+declare function useRef<T>(initialValue: T): RefObject<T>;
+declare function useRef<T>(initialValue: T | null): RefObject<T | null>;
+declare function useRef<T = undefined>(): RefObject<T | undefined>;
+
+/**
+ * Returns a memoized value. `factory` is only re-executed when one of the
+ * `deps` changes (using `Object.is` comparison), otherwise the cached value
+ * from the previous render is returned unchanged.
+ *
+ * @example
+ * const sorted = useMemo(() => [...list].sort(), [list]);
+ */
+declare function useMemo<T>(factory: () => T, deps: any[]): T;
+
+/**
+ * Returns a memoized callback. The same function reference is returned on
+ * every render unless one of the `deps` changes.
+ *
+ * This is sugar over `useMemo(() => fn, deps)` — it keeps function identity
+ * stable so child components that compare props by reference don't re-render
+ * unnecessarily.
+ *
+ * @example
+ * const handleClick = useCallback(() => doSomething(id), [id]);
+ */
+declare function useCallback<T extends (...args: any[]) => any>(callback: T, deps: any[]): T;
+
+/**
+ * A context object that is also its own Provider component.
+ * Both forms are equivalent:
+ *   jsx(MyContext, { value, children })           // Context as Provider
+ *   jsx(MyContext.Provider, { value, children })  // Classic Provider form
+ */
+type RectifyContext<T> = {
+    (props: {
+        value: T;
+        children?: any;
+    }): null;
+    /** Self-reference used by the reconciler to identify Provider fibers. */
+    _context: RectifyContext<T>;
+    _defaultValue: T;
+    _subscribers: Set<Fiber>;
+    /** Alias to self — `Context.Provider === Context`. */
+    Provider: RectifyContext<T>;
+};
+/**
+ * Creates a new context. The returned object is itself a Provider component,
+ * so both forms below are equivalent:
+ *
+ * @example
+ * const ThemeCtx = createContext<'light' | 'dark'>('light');
+ *
+ * // Option A – Context used directly as Provider
+ * jsx(ThemeCtx, { value: 'dark', children: ... })
+ *
+ * // Option B – Classic .Provider form
+ * jsx(ThemeCtx.Provider, { value: 'dark', children: ... })
+ */
+declare function createContext<T>(defaultValue: T): RectifyContext<T>;
+/**
+ * Reads the current value of `context` for the calling component.
+ *
+ * Walks up the fiber tree to the nearest matching Provider and reads its
+ * `pendingProps.value` directly — no render-time stack required. This means
+ * the correct value is always returned even when the Provider did not
+ * re-render in the current pass.
+ *
+ * The component re-renders whenever the nearest Provider supplies a new value
+ * (compared with `Object.is`). Unlike other hooks this does NOT consume a
+ * hook slot and may be called conditionally.
+ *
+ * @example
+ * const theme = useContext(ThemeCtx); // 'light' | 'dark'
+ */
+declare function useContext<T>(context: RectifyContext<T>): T;
+
+export { type MemoComponent, type RectifyContext, type RefObject, SyntheticEvent, createContext, createRoot, memo, useCallback, useContext, useEffect, useLayoutEffect, useMemo, useRef, useState };

package/dist/index.d.ts

@@ -1,8 +1,24 @@
-import { FC } from '@rectify-dev/shared';
+import { RectifyNode, FC, Fiber } from '@rectify-dev/shared';
 export { AnchorHTMLAttributes, AriaAttributes, AudioHTMLAttributes, ButtonHTMLAttributes, CSSProperties, FC, FormHTMLAttributes, HTMLAttributes, IframeHTMLAttributes, ImgHTMLAttributes, InputHTMLAttributes, LabelHTMLAttributes, MetaHTMLAttributes, OptGroupHTMLAttributes, OptionHTMLAttributes, RectifyEventHandlers, RectifyIntrinsicElements, ScriptHTMLAttributes, SelectHTMLAttributes, SyntheticAnimationEvent, SyntheticChangeEvent, SyntheticClipboardEvent, SyntheticDragEvent, SyntheticEvent as SyntheticEventType, SyntheticFocusEvent, SyntheticInputEvent, SyntheticKeyboardEvent, SyntheticMouseEvent, SyntheticPointerEvent, SyntheticSubmitEvent, SyntheticTouchEvent, SyntheticTransitionEvent, SyntheticWheelEvent, TextareaHTMLAttributes, VideoHTMLAttributes } from '@rectify-dev/shared';
-export { SyntheticEvent, createRoot } from '@rectify-dev/dom';
 export { Fragment, jsx } from './runtime.js';
-export { RectifyContext, RefObject, createContext, useCallback, useContext, useEffect, useLayoutEffect, useMemo, useRef, useState } from '@rectify-dev/hook';
+
+type RectifyDomRoot = {
+    render: (node: RectifyNode) => void;
+    unmount: () => void;
+};
+declare const createRoot: (container: Element) => RectifyDomRoot;
+
+type AnyNativeEvent = Event | KeyboardEvent | MouseEvent | TouchEvent;
+
+declare class SyntheticEvent {
+    target: Element | null;
+    currentTarget: Element | null;
+    nativeEvent: AnyNativeEvent;
+    private propagationStopped;
+    constructor(nativeEvent: AnyNativeEvent);
+    stopPropagation(): void;
+    isPropagationStopped(): boolean;
+}
 
 type MemoComponent<P = any> = FC<P> & {
     /** Marks this as a memo-wrapped component for the reconciler. */
@@ -28,4 +44,117 @@ type MemoComponent<P = any> = FC<P> & {
  */
 declare function memo<P = any>(Component: FC<P>, compare?: (prevProps: P, nextProps: P) => boolean): MemoComponent<P>;
 
-export { type MemoComponent, memo };
+type StateUpdater<S> = S | ((prevState: S) => S);
+type StateDispatcher<S> = (updater: StateUpdater<S>) => void;
+
+declare function useState<S>(): [S | undefined, StateDispatcher<S | undefined>];
+declare function useState<S>(initialState: S): [S, StateDispatcher<S>];
+declare function useState<S>(initialState: () => S): [S, StateDispatcher<S>];
+
+declare function useEffect(create: () => void | (() => void), deps?: any[]): void;
+
+/**
+ * Like `useEffect`, but fires **synchronously after every DOM mutation** and
+ * before the browser has a chance to paint.  Use this when you need to read
+ * layout or synchronously re-style the DOM (tooltips, scroll restoration,
+ * measuring element sizes, etc.).
+ *
+ * Prefer `useEffect` for everything else — `useLayoutEffect` blocks the paint.
+ *
+ * @example
+ * useLayoutEffect(() => {
+ *   const { height } = ref.current.getBoundingClientRect();
+ *   setTooltipTop(-height);
+ * }, []);
+ */
+declare function useLayoutEffect(create: () => void | (() => void), deps?: any[]): void;
+
+type RefObject<T> = {
+    current: T;
+};
+/**
+ * Returns a stable mutable ref object whose `.current` property is initialised
+ * to `initialValue`.  The same object is returned on every render — updating
+ * `.current` does NOT trigger a re-render.
+ *
+ * Two common uses:
+ *   1. Hold a DOM node:   const el = useRef<HTMLDivElement>(null)
+ *   2. Hold a mutable value across renders without causing re-renders.
+ */
+declare function useRef<T>(initialValue: T): RefObject<T>;
+declare function useRef<T>(initialValue: T | null): RefObject<T | null>;
+declare function useRef<T = undefined>(): RefObject<T | undefined>;
+
+/**
+ * Returns a memoized value. `factory` is only re-executed when one of the
+ * `deps` changes (using `Object.is` comparison), otherwise the cached value
+ * from the previous render is returned unchanged.
+ *
+ * @example
+ * const sorted = useMemo(() => [...list].sort(), [list]);
+ */
+declare function useMemo<T>(factory: () => T, deps: any[]): T;
+
+/**
+ * Returns a memoized callback. The same function reference is returned on
+ * every render unless one of the `deps` changes.
+ *
+ * This is sugar over `useMemo(() => fn, deps)` — it keeps function identity
+ * stable so child components that compare props by reference don't re-render
+ * unnecessarily.
+ *
+ * @example
+ * const handleClick = useCallback(() => doSomething(id), [id]);
+ */
+declare function useCallback<T extends (...args: any[]) => any>(callback: T, deps: any[]): T;
+
+/**
+ * A context object that is also its own Provider component.
+ * Both forms are equivalent:
+ *   jsx(MyContext, { value, children })           // Context as Provider
+ *   jsx(MyContext.Provider, { value, children })  // Classic Provider form
+ */
+type RectifyContext<T> = {
+    (props: {
+        value: T;
+        children?: any;
+    }): null;
+    /** Self-reference used by the reconciler to identify Provider fibers. */
+    _context: RectifyContext<T>;
+    _defaultValue: T;
+    _subscribers: Set<Fiber>;
+    /** Alias to self — `Context.Provider === Context`. */
+    Provider: RectifyContext<T>;
+};
+/**
+ * Creates a new context. The returned object is itself a Provider component,
+ * so both forms below are equivalent:
+ *
+ * @example
+ * const ThemeCtx = createContext<'light' | 'dark'>('light');
+ *
+ * // Option A – Context used directly as Provider
+ * jsx(ThemeCtx, { value: 'dark', children: ... })
+ *
+ * // Option B – Classic .Provider form
+ * jsx(ThemeCtx.Provider, { value: 'dark', children: ... })
+ */
+declare function createContext<T>(defaultValue: T): RectifyContext<T>;
+/**
+ * Reads the current value of `context` for the calling component.
+ *
+ * Walks up the fiber tree to the nearest matching Provider and reads its
+ * `pendingProps.value` directly — no render-time stack required. This means
+ * the correct value is always returned even when the Provider did not
+ * re-render in the current pass.
+ *
+ * The component re-renders whenever the nearest Provider supplies a new value
+ * (compared with `Object.is`). Unlike other hooks this does NOT consume a
+ * hook slot and may be called conditionally.
+ *
+ * @example
+ * const theme = useContext(ThemeCtx); // 'light' | 'dark'
+ */
+declare function useContext<T>(context: RectifyContext<T>): T;
+
+export { type MemoComponent, type RectifyContext, type RefObject, SyntheticEvent, createContext, createRoot, memo, useCallback, useContext, useEffect, useLayoutEffect, useMemo, useRef, useState };

package/dist/index.js

@@ -1,7 +1,6 @@
 import { __name } from './chunk-2FA4QXYL.js';
 export { Fragment, jsx } from './chunk-2FA4QXYL.js';
 import { isFunction, shallowEqual, createElementFromRectifyNode, isValidRectifyElement, isArray, isPlainObject, omit, RECTIFY_FRAGMENT_TYPE, RECTIFY_TEXT_TYPE, RECTIFY_ELEMENT_TYPE } from '@rectify-dev/shared';
-export { FC } from '@rectify-dev/shared';
 
 // ../rectify-dom-binding/src/events/RectifyEventRegistry.ts
 var allNativeEvents = /* @__PURE__ */ new Set();