hadars 0.1.16 → 0.1.18

package/dist/slim-react/index.d.ts

@@ -0,0 +1,180 @@
+import { S as SlimNode, a as SlimElement, c as createElement } from '../jsx-runtime-97ca74a5.js';
+export { C as ComponentFunction, d as FRAGMENT_TYPE, F as Fragment, b as SLIM_ELEMENT, e as SUSPENSE_TYPE, j as jsx, j as jsxDEV, j as jsxs } from '../jsx-runtime-97ca74a5.js';
+
+/**
+ * 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.
+ */
+declare function useState<T>(initialState: T | (() => T)): [T, (value: T | ((prev: T) => T)) => void];
+declare function useReducer<S, A>(_reducer: (state: S, action: A) => S, initialState: S): [S, (action: A) => void];
+declare function useEffect(_effect: () => void | (() => void), _deps?: any[]): void;
+declare function useLayoutEffect(_effect: () => void | (() => void), _deps?: any[]): void;
+declare function useInsertionEffect(_effect: () => void | (() => void), _deps?: any[]): void;
+declare function useRef<T>(initialValue: T): {
+    current: T;
+};
+declare function useMemo<T>(factory: () => T, _deps?: any[]): T;
+declare function useCallback<T extends Function>(callback: T, _deps?: any[]): T;
+declare function useId(): string;
+declare function useDebugValue(_value: any, _format?: (v: any) => any): void;
+declare function useImperativeHandle(_ref: any, _createHandle: () => any, _deps?: any[]): void;
+declare function useSyncExternalStore<T>(_subscribe: (onStoreChange: () => void) => () => void, getSnapshot: () => T, getServerSnapshot?: () => T): T;
+declare function useTransition(): [boolean, (callback: () => void) => void];
+declare function useDeferredValue<T>(value: T): T;
+declare function useOptimistic<T>(passthrough: T): [T, () => void];
+declare function useFormStatus(): {
+    pending: boolean;
+    data: null;
+    method: null;
+    action: null;
+};
+declare function useActionState<S>(_action: (state: S, payload: any) => S | Promise<S>, initialState: S, _permalink?: string): [S, (payload: any) => void, boolean];
+declare function use<T>(usable: (Promise<T> & {
+    status?: string;
+    value?: T;
+    reason?: any;
+}) | {
+    _currentValue: T;
+}): T;
+declare function startTransition(callback: () => void): void;
+
+/**
+ * Minimal Context implementation for SSR.
+ *
+ * Because SSR is single-pass and synchronous within each component,
+ * we just track the "current" value on the context object and
+ * save / restore around Provider renders (handled by the renderer).
+ */
+interface Context<T> {
+    _currentValue: T;
+    Provider: ContextProvider<T>;
+    Consumer: (props: {
+        children: (value: T) => SlimNode;
+    }) => SlimNode;
+}
+type ContextProvider<T> = ((props: {
+    value: T;
+    children?: SlimNode;
+}) => SlimNode) & {
+    _context: Context<T>;
+};
+declare function createContext<T>(defaultValue: T): Context<T>;
+
+/**
+ * Streaming SSR renderer with Suspense support.
+ *
+ * `renderToStream` walks the virtual-node tree produced by jsx() /
+ * createElement() and writes HTML chunks into a ReadableStream.
+ *
+ * When it meets a <Suspense> boundary it:
+ *   1. Tries to render the children into a temporary buffer.
+ *   2. If a child throws a Promise (React Suspense protocol) it
+ *      awaits the promise, then retries from step 1.
+ *   3. Once successful, the buffer is flushed to the real stream.
+ *
+ * The net effect is that the stream **pauses** at Suspense boundaries
+ * until the async data is ready, then continues – exactly as requested.
+ */
+
+/**
+ * Render a component tree to a `ReadableStream<Uint8Array>`.
+ *
+ * The stream pauses at `<Suspense>` boundaries until the suspended
+ * promise resolves, then continues writing HTML.
+ */
+declare function renderToStream(element: SlimNode): ReadableStream<Uint8Array>;
+/**
+ * Convenience: render to a complete HTML string.
+ * Retries the full tree when a component throws a Promise (Suspense protocol),
+ * so useServerData and similar hooks work without requiring explicit <Suspense>.
+ */
+declare function renderToString(element: SlimNode): Promise<string>;
+
+/**
+ * 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.
+ */
+
+declare function useContext<T>(context: Context<T>): T;
+
+declare const Suspense: symbol;
+
+declare function isValidElement(obj: unknown): obj is SlimElement;
+declare function cloneElement(element: SlimElement, overrideProps?: Record<string, any>, ...children: SlimNode[]): SlimElement;
+declare function forwardRef<P = any>(render: (props: P, ref: any) => SlimNode): (props: P & {
+    ref?: any;
+}) => SlimNode;
+declare function memo<P = any>(component: (props: P) => SlimNode): (props: P) => SlimNode;
+declare function lazy<P = any>(factory: () => Promise<{
+    default: (props: P) => SlimNode;
+}>): (props: P) => SlimNode;
+declare function toFlatArray(children: SlimNode): SlimNode[];
+declare const Children: {
+    map(children: SlimNode, fn: (child: SlimNode, index: number) => SlimNode): SlimNode[];
+    forEach(children: SlimNode, fn: (child: SlimNode, index: number) => void): void;
+    count(children: SlimNode): number;
+    only(children: SlimNode): SlimElement;
+    toArray: typeof toFlatArray;
+};
+declare class Component<P = {}, S = {}> {
+    props: P;
+    state: S;
+    context: any;
+    constructor(props: P);
+    setState(_partial: Partial<S> | ((prev: S) => Partial<S>)): void;
+    forceUpdate(): void;
+    render(): SlimNode;
+}
+declare class PureComponent<P = {}, S = {}> extends Component<P, S> {
+}
+declare const React: {
+    useState: typeof useState;
+    useReducer: typeof useReducer;
+    useEffect: typeof useEffect;
+    useLayoutEffect: typeof useLayoutEffect;
+    useInsertionEffect: typeof useInsertionEffect;
+    useRef: typeof useRef;
+    useMemo: typeof useMemo;
+    useCallback: typeof useCallback;
+    useId: typeof useId;
+    useDebugValue: typeof useDebugValue;
+    useImperativeHandle: typeof useImperativeHandle;
+    useSyncExternalStore: typeof useSyncExternalStore;
+    useTransition: typeof useTransition;
+    useDeferredValue: typeof useDeferredValue;
+    useOptimistic: typeof useOptimistic;
+    useFormStatus: typeof useFormStatus;
+    useActionState: typeof useActionState;
+    use: typeof use;
+    startTransition: typeof startTransition;
+    createContext: typeof createContext;
+    useContext: typeof useContext;
+    createElement: typeof createElement;
+    cloneElement: typeof cloneElement;
+    isValidElement: typeof isValidElement;
+    forwardRef: typeof forwardRef;
+    memo: typeof memo;
+    lazy: typeof lazy;
+    Fragment: symbol;
+    Suspense: symbol;
+    Children: {
+        map(children: SlimNode, fn: (child: SlimNode, index: number) => SlimNode): SlimNode[];
+        forEach(children: SlimNode, fn: (child: SlimNode, index: number) => void): void;
+        count(children: SlimNode): number;
+        only(children: SlimNode): SlimElement;
+        toArray: typeof toFlatArray;
+    };
+    Component: typeof Component;
+    PureComponent: typeof PureComponent;
+    renderToStream: typeof renderToStream;
+    renderToString: typeof renderToString;
+    renderToReadableStream: typeof renderToStream;
+    version: string;
+};
+
+export { Children, Component, Context, PureComponent, SlimElement, SlimNode, Suspense, cloneElement, createContext, createElement, React as default, forwardRef, isValidElement, lazy, memo, renderToStream as renderToReadableStream, renderToStream, renderToString, startTransition, use, useActionState, useCallback, useContext, useDebugValue, useDeferredValue, useEffect, useFormStatus, useId, useImperativeHandle, useInsertionEffect, useLayoutEffect, useMemo, useOptimistic, useReducer, useRef, useState, useSyncExternalStore, useTransition };