hadars 0.4.1 → 0.4.2

package/src/slim-react/hooks.ts

@@ -1,137 +0,0 @@
-/**
- * SSR hook implementations.
- *
- * On the server every hook is either a no-op or returns the initial /
- * snapshot value.  This is enough for the vast majority of React-
- * compatible libraries to work during server-side rendering.
- */
-
-import { makeId, getContextValue } from "./renderContext";
-
-// ---- useState ----
-export function useState<T>(
-  initialState: T | (() => T),
-): [T, (value: T | ((prev: T) => T)) => void] {
-  const value =
-    typeof initialState === "function"
-      ? (initialState as () => T)()
-      : initialState;
-  return [value, () => {}];
-}
-
-// ---- useReducer ----
-export function useReducer<S, A>(
-  _reducer: (state: S, action: A) => S,
-  initialState: S,
-): [S, (action: A) => void] {
-  return [initialState, () => {}];
-}
-
-// ---- useEffect / useLayoutEffect / useInsertionEffect ----
-export function useEffect(
-  _effect: () => void | (() => void),
-  _deps?: any[],
-) {}
-export function useLayoutEffect(
-  _effect: () => void | (() => void),
-  _deps?: any[],
-) {}
-export function useInsertionEffect(
-  _effect: () => void | (() => void),
-  _deps?: any[],
-) {}
-
-// ---- useRef ----
-export function useRef<T>(initialValue: T): { current: T } {
-  return { current: initialValue };
-}
-
-// ---- useMemo / useCallback ----
-export function useMemo<T>(factory: () => T, _deps?: any[]): T {
-  return factory();
-}
-export function useCallback<T extends Function>(callback: T, _deps?: any[]): T {
-  return callback;
-}
-
-// ---- useId ----
-export function useId(): string {
-  return makeId();
-}
-
-// ---- useDebugValue ----
-export function useDebugValue(_value: any, _format?: (v: any) => any) {}
-
-// ---- useImperativeHandle ----
-export function useImperativeHandle(
-  _ref: any,
-  _createHandle: () => any,
-  _deps?: any[],
-) {}
-
-// ---- useSyncExternalStore ----
-export function useSyncExternalStore<T>(
-  _subscribe: (onStoreChange: () => void) => () => void,
-  getSnapshot: () => T,
-  getServerSnapshot?: () => T,
-): T {
-  return (getServerSnapshot || getSnapshot)();
-}
-
-// ---- useTransition ----
-export function useTransition(): [boolean, (callback: () => void) => void] {
-  return [false, (cb) => cb()];
-}
-
-// ---- useDeferredValue ----
-export function useDeferredValue<T>(value: T): T {
-  return value;
-}
-
-// ---- useOptimistic (React 19) ----
-export function useOptimistic<T>(passthrough: T): [T, () => void] {
-  return [passthrough, () => {}];
-}
-
-// ---- useFormStatus (React 19) ----
-export function useFormStatus() {
-  return { pending: false, data: null, method: null, action: null };
-}
-
-// ---- useActionState (React 19) ----
-export function useActionState<S>(
-  _action: (state: S, payload: any) => S | Promise<S>,
-  initialState: S,
-  _permalink?: string,
-): [S, (payload: any) => void, boolean] {
-  return [initialState, () => {}, false];
-}
-
-// ---- use (React 19 – Suspense integration) ----
-export function use<T>(
-  usable: (Promise<T> & { status?: string; value?: T; reason?: any }) | { _currentValue: T },
-): T {
-  // Context object
-  if (
-    typeof usable === "object" &&
-    usable !== null &&
-    ("_currentValue" in usable || "_defaultValue" in usable)
-  ) {
-    return getContextValue<T>(usable as object);
-  }
-
-  // Promise – Suspense protocol
-  const promise = usable as Promise<T> & {
-    status?: string;
-    value?: T;
-    reason?: any;
-  };
-  if (promise.status === "fulfilled") return promise.value!;
-  if (promise.status === "rejected") throw promise.reason;
-  throw promise; // caught by the nearest Suspense boundary
-}
-
-// ---- startTransition ----
-export function startTransition(callback: () => void) {
-  callback();
-}

package/src/slim-react/index.ts

@@ -1,232 +0,0 @@
-/**
- * slim-react – a lightweight, SSR-only React-compatible runtime.
- *
- * Provides just enough of the React API surface to server-render
- * components that use hooks, Context and Suspense.
- */
-
-// ---- Symbols & types ----
-export {
-  SLIM_ELEMENT,
-  FRAGMENT_TYPE,
-  SUSPENSE_TYPE,
-  type SlimElement,
-  type SlimNode,
-  type ComponentFunction,
-} from "./types";
-
-// ---- JSX runtime ----
-import { jsx, jsxs, jsxDEV, createElement, Fragment } from "./jsx";
-export { jsx, jsxs, jsxDEV, createElement, Fragment };
-
-// ---- Hooks (SSR stubs) ----
-import {
-  useState,
-  useReducer,
-  useEffect,
-  useLayoutEffect,
-  useInsertionEffect,
-  useRef,
-  useMemo,
-  useCallback,
-  useId,
-  useDebugValue,
-  useImperativeHandle,
-  useSyncExternalStore,
-  useTransition,
-  useDeferredValue,
-  useOptimistic,
-  useFormStatus,
-  useActionState,
-  use,
-  startTransition,
-} from "./hooks";
-export {
-  useState,
-  useReducer,
-  useEffect,
-  useLayoutEffect,
-  useInsertionEffect,
-  useRef,
-  useMemo,
-  useCallback,
-  useId,
-  useDebugValue,
-  useImperativeHandle,
-  useSyncExternalStore,
-  useTransition,
-  useDeferredValue,
-  useOptimistic,
-  useFormStatus,
-  useActionState,
-  use,
-  startTransition,
-};
-
-// ---- Context ----
-import { createContext } from "./context";
-export { createContext, type Context } from "./context";
-
-import { getContextValue } from "./renderContext";
-import type { Context } from "./context";
-export function useContext<T>(context: Context<T>): T {
-  return getContextValue<T>(context);
-}
-
-// ---- Rendering ----
-import { renderToStream, renderToString, renderToReadableStream, renderPreflight } from "./render";
-export { renderToStream, renderToString, renderToReadableStream, renderPreflight, type RenderOptions } from "./render";
-
-// ---- Suspense (as a JSX tag) ----
-import { SUSPENSE_TYPE } from "./types";
-export const Suspense = SUSPENSE_TYPE;
-
-// ---- Compat utilities ----
-import { SLIM_ELEMENT, REACT19_ELEMENT, type SlimElement, type SlimNode } from "./types";
-
-export function isValidElement(obj: unknown): obj is SlimElement {
-  if (typeof obj !== "object" || obj === null) return false;
-  const t = (obj as any).$$typeof;
-  return t === SLIM_ELEMENT || t === REACT19_ELEMENT;
-}
-
-export function cloneElement(
-  element: SlimElement,
-  overrideProps?: Record<string, any>,
-  ...children: SlimNode[]
-): SlimElement {
-  return {
-    $$typeof: (element as any).$$typeof || SLIM_ELEMENT,
-    type: element.type,
-    props: {
-      ...element.props,
-      ...overrideProps,
-      ...(children.length === 1
-        ? { children: children[0] }
-        : children.length > 1
-          ? { children }
-          : {}),
-    },
-    key: overrideProps?.key ?? element.key,
-  };
-}
-
-export function forwardRef<P = any>(
-  render: (props: P, ref: any) => SlimNode,
-): any {
-  return {
-    $$typeof: Symbol.for("react.forward_ref"),
-    render,
-    displayName: (render as any).displayName || (render as any).name || "ForwardRef",
-  };
-}
-
-export function memo<P = any>(
-  component: (props: P) => SlimNode,
-  compare?: (prevProps: P, nextProps: P) => boolean,
-): any {
-  return {
-    $$typeof: Symbol.for("react.memo"),
-    type: component,
-    compare: compare ?? null,
-  };
-}
-
-export function lazy<P = any>(
-  factory: () => Promise<{ default: (props: P) => SlimNode }>,
-): (props: P) => SlimNode {
-  let resolved: ((props: P) => SlimNode) | null = null;
-  let promise: Promise<void> | null = null;
-
-  return function LazyComponent(props: P): SlimNode {
-    if (resolved) return resolved(props);
-    if (!promise) {
-      promise = factory().then((mod) => {
-        resolved = mod.default;
-      });
-    }
-    throw promise; // Suspense protocol
-  };
-}
-
-// ---- Children helpers ----
-function toFlatArray(children: SlimNode): SlimNode[] {
-  if (children == null || typeof children === "boolean") return [];
-  if (Array.isArray(children)) return children.flatMap(toFlatArray);
-  return [children];
-}
-
-export const Children = {
-  map(
-    children: SlimNode,
-    fn: (child: SlimNode, index: number) => SlimNode,
-  ): SlimNode[] {
-    return toFlatArray(children).map((child, i) => fn(child, i));
-  },
-  forEach(
-    children: SlimNode,
-    fn: (child: SlimNode, index: number) => void,
-  ): void {
-    toFlatArray(children).forEach((child, i) => fn(child, i));
-  },
-  count(children: SlimNode): number {
-    return toFlatArray(children).length;
-  },
-  only(children: SlimNode): SlimElement {
-    const arr = toFlatArray(children);
-    if (arr.length !== 1) throw new Error("Children.only expected one child");
-    return arr[0] as SlimElement;
-  },
-  toArray: toFlatArray,
-};
-
-// ---- React.Component (basic class component support) ----
-export class Component<P = {}, S = {}> {
-  props: P;
-  state: S;
-  context: any;
-
-  constructor(props: P) {
-    this.props = props;
-    this.state = {} as S;
-  }
-
-  setState(_partial: Partial<S> | ((prev: S) => Partial<S>)) {}
-  forceUpdate() {}
-  render(): SlimNode {
-    return null;
-  }
-}
-
-export class PureComponent<P = {}, S = {}> extends Component<P, S> {}
-
-// ---- Version ----
-// Exported as a named export so that namespace imports (`import * as React`)
-// — as used by react-redux and other libraries that check React.version —
-// find it on the module namespace rather than only on the default export.
-export const version = "19.1.1";
-
-// ---- Default export ----
-// Mirrors `import React from 'react'` so code that uses React.useState,
-// React.createContext, React.Suspense, etc. works without changes.
-// All names here are already imported/defined above — no re-imports needed.
-const React = {
-  // Hooks
-  useState, useReducer, useEffect, useLayoutEffect, useInsertionEffect,
-  useRef, useMemo, useCallback, useId, useDebugValue, useImperativeHandle,
-  useSyncExternalStore, useTransition, useDeferredValue,
-  useOptimistic, useFormStatus, useActionState, use, startTransition,
-  // Context
-  createContext, useContext,
-  // Elements
-  createElement, cloneElement, isValidElement, forwardRef, memo, lazy,
-  Fragment, Suspense,
-  // Compat
-  Children, Component, PureComponent,
-  // Rendering
-  renderToStream, renderToString, renderToReadableStream, renderPreflight,
-  // Version
-  version,
-};
-
-export default React;

package/src/slim-react/jsx-runtime.ts

@@ -1,7 +0,0 @@
-/**
- * JSX automatic-transform runtime for slim-react.
- *
- * Aliased from `react/jsx-runtime` in SSR rspack builds so that the
- * automatic JSX transform produces slim-react elements instead of React ones.
- */
-export { jsx, jsxs, jsxDEV, Fragment } from "./jsx";

package/src/slim-react/jsx.ts

@@ -1,53 +0,0 @@
-import {
-  SLIM_ELEMENT,
-  FRAGMENT_TYPE,
-  type SlimElement,
-  type SlimNode,
-  type ComponentFunction,
-} from "./types";
-
-// ---- Fragment ----
-export const Fragment = FRAGMENT_TYPE;
-
-// ---- jsx / jsxs (automatic transform) ----
-// The automatic JSX transform calls jsx(type, props, key?)
-// where props already contains `children`.
-export function jsx(
-  type: string | ComponentFunction | symbol,
-  props: Record<string, any>,
-  key?: string | number | null,
-): SlimElement {
-  return {
-    $$typeof: SLIM_ELEMENT,
-    type,
-    props: props || {},
-    key: key ?? (props?.key ?? null),
-  };
-}
-
-export { jsx as jsxs, jsx as jsxDEV };
-
-// ---- createElement (classic transform) ----
-export function createElement(
-  type: string | ComponentFunction | symbol,
-  props?: Record<string, any> | null,
-  ...children: SlimNode[]
-): SlimElement {
-  const normalizedProps: Record<string, any> = { ...(props || {}) };
-
-  if (children.length === 1) {
-    normalizedProps.children = children[0];
-  } else if (children.length > 1) {
-    normalizedProps.children = children;
-  }
-
-  const key = normalizedProps.key ?? null;
-  delete normalizedProps.key;
-
-  return {
-    $$typeof: SLIM_ELEMENT,
-    type,
-    props: normalizedProps,
-    key,
-  };
-}