@enjoys/context-engine 1.3.1 → 1.4.2

package/data/definition/react.json

@@ -0,0 +1,397 @@
+{
+  "language": "react",
+  "definitions": {
+    "useState": {
+      "signature": "function useState<S>(initialState: S | (() => S)): [S, Dispatch<SetStateAction<S>>]",
+      "description": "Returns a stateful value, and a function to update it. During the initial render, the returned state is the same as the value passed as the first argument. The setState function is used to update the state and trigger a re-render.",
+      "type": "function",
+      "module": "react",
+      "url": "https://react.dev/reference/react/useState"
+    },
+    "useEffect": {
+      "signature": "function useEffect(effect: EffectCallback, deps?: DependencyList): void",
+      "description": "Accepts a function that contains imperative, possibly effectful code. The function passed to useEffect will run after the render is committed to the screen. Effects run after every completed render by default, but can be configured to fire only when certain values have changed.",
+      "type": "function",
+      "module": "react",
+      "url": "https://react.dev/reference/react/useEffect"
+    },
+    "useContext": {
+      "signature": "function useContext<T>(context: Context<T>): T",
+      "description": "Accepts a context object (the value returned from React.createContext) and returns the current context value for that context. The current context value is determined by the value prop of the nearest <MyContext.Provider> above the calling component in the tree.",
+      "type": "function",
+      "module": "react",
+      "url": "https://react.dev/reference/react/useContext"
+    },
+    "useReducer": {
+      "signature": "function useReducer<R extends Reducer<any, any>>(reducer: R, initialState: ReducerState<R>, initializer?: (arg: ReducerState<R>) => ReducerState<R>): [ReducerState<R>, Dispatch<ReducerAction<R>>]",
+      "description": "An alternative to useState for managing complex state logic. Accepts a reducer of type (state, action) => newState, and returns the current state paired with a dispatch method.",
+      "type": "function",
+      "module": "react",
+      "url": "https://react.dev/reference/react/useReducer"
+    },
+    "useMemo": {
+      "signature": "function useMemo<T>(factory: () => T, deps: DependencyList): T",
+      "description": "Returns a memoized value. Only recomputes the memoized value when one of the dependencies has changed. This optimization helps to avoid expensive calculations on every render.",
+      "type": "function",
+      "module": "react",
+      "url": "https://react.dev/reference/react/useMemo"
+    },
+    "useCallback": {
+      "signature": "function useCallback<T extends Function>(callback: T, deps: DependencyList): T",
+      "description": "Returns a memoized callback. The callback only changes if one of the dependencies has changed. Useful when passing callbacks to optimized child components that rely on reference equality.",
+      "type": "function",
+      "module": "react",
+      "url": "https://react.dev/reference/react/useCallback"
+    },
+    "useRef": {
+      "signature": "function useRef<T>(initialValue: T): MutableRefObject<T>",
+      "description": "Returns a mutable ref object whose .current property is initialized to the passed argument. The returned object will persist for the full lifetime of the component. Commonly used to access DOM elements.",
+      "type": "function",
+      "module": "react",
+      "url": "https://react.dev/reference/react/useRef"
+    },
+    "useLayoutEffect": {
+      "signature": "function useLayoutEffect(effect: EffectCallback, deps?: DependencyList): void",
+      "description": "Identical to useEffect, but fires synchronously after all DOM mutations. Use this to read layout from the DOM and synchronously re-render. Updates scheduled inside will be flushed synchronously before the browser has a chance to paint.",
+      "type": "function",
+      "module": "react",
+      "url": "https://react.dev/reference/react/useLayoutEffect"
+    },
+    "useId": {
+      "signature": "function useId(): string",
+      "description": "Generates unique IDs that are stable across the server and client, while avoiding hydration mismatches. Primarily used for accessibility attributes like htmlFor.",
+      "type": "function",
+      "module": "react",
+      "url": "https://react.dev/reference/react/useId"
+    },
+    "useTransition": {
+      "signature": "function useTransition(): [boolean, (callback: () => void) => void]",
+      "description": "Returns a stateful value for the pending state of the transition, and a function to start it. Allows marking updates as transitions so they can be interrupted by more urgent updates.",
+      "type": "function",
+      "module": "react",
+      "url": "https://react.dev/reference/react/useTransition"
+    },
+    "useDeferredValue": {
+      "signature": "function useDeferredValue<T>(value: T): T",
+      "description": "Accepts a value and returns a new copy of the value that will defer to more urgent updates. If the current render is the result of an urgent update, React will return the previous value and render the new value after the urgent render.",
+      "type": "function",
+      "module": "react",
+      "url": "https://react.dev/reference/react/useDeferredValue"
+    },
+    "useSyncExternalStore": {
+      "signature": "function useSyncExternalStore<T>(subscribe: (onStoreChange: () => void) => () => void, getSnapshot: () => T, getServerSnapshot?: () => T): T",
+      "description": "Subscribes to an external store. Recommended for libraries that integrate with state management solutions outside React. Ensures the component re-renders when the store changes.",
+      "type": "function",
+      "module": "react",
+      "url": "https://react.dev/reference/react/useSyncExternalStore"
+    },
+    "useImperativeHandle": {
+      "signature": "function useImperativeHandle<T, R extends T>(ref: Ref<T>, createHandle: () => R, deps?: DependencyList): void",
+      "description": "Customizes the instance value that is exposed to parent components when using ref. Should be used with forwardRef. Allows you to control what values are exposed on a ref.",
+      "type": "function",
+      "module": "react",
+      "url": "https://react.dev/reference/react/useImperativeHandle"
+    },
+    "useDebugValue": {
+      "signature": "function useDebugValue<T>(value: T, format?: (value: T) => any): void",
+      "description": "Used to display a label for custom hooks in React DevTools. Accepts a value to display and an optional formatting function.",
+      "type": "function",
+      "module": "react",
+      "url": "https://react.dev/reference/react/useDebugValue"
+    },
+    "useInsertionEffect": {
+      "signature": "function useInsertionEffect(effect: EffectCallback, deps?: DependencyList): void",
+      "description": "Fires synchronously before all DOM mutations. Use this to inject styles into the DOM before any effects that might read layout. Primarily for CSS-in-JS library authors.",
+      "type": "function",
+      "module": "react",
+      "url": "https://react.dev/reference/react/useInsertionEffect"
+    },
+    "useOptimistic": {
+      "signature": "function useOptimistic<T, A>(passthrough: T, reducer: (state: T, action: A) => T): [T, (action: A) => void]",
+      "description": "Allows you to show a different state while an async action is underway. It accepts some state and returns a copy of that state that can be different during the async action. Useful for optimistic UI updates.",
+      "type": "function",
+      "module": "react",
+      "url": "https://react.dev/reference/react/useOptimistic"
+    },
+    "useFormStatus": {
+      "signature": "function useFormStatus(): { pending: boolean; data: FormData | null; method: string | null; action: string | null }",
+      "description": "Gives you status information of the last form submission. Must be called from a component rendered inside a <form>. Returns the pending status and submitted form data.",
+      "type": "function",
+      "module": "react-dom",
+      "url": "https://react.dev/reference/react-dom/hooks/useFormStatus"
+    },
+    "useActionState": {
+      "signature": "function useActionState<T>(action: (state: T, payload: FormData) => T | Promise<T>, initialState: T, permalink?: string): [T, (payload: FormData) => void]",
+      "description": "Allows you to update state based on the result of a form action. It is useful for using form actions to update state. Returns the current state and a wrapped action function.",
+      "type": "function",
+      "module": "react",
+      "url": "https://react.dev/reference/react/useActionState"
+    },
+    "use": {
+      "signature": "function use<T>(resource: Promise<T> | Context<T>): T",
+      "description": "Reads the value of a resource like a Promise or context. Unlike other hooks, use can be called conditionally and inside loops. When called with a Promise, it integrates with Suspense.",
+      "type": "function",
+      "module": "react",
+      "url": "https://react.dev/reference/react/use"
+    },
+    "createElement": {
+      "signature": "function createElement(type: string | ComponentType, props?: object, ...children: ReactNode[]): ReactElement",
+      "description": "Creates and returns a new React element of the given type. JSX is compiled to createElement calls. The type argument can be a tag name string, a React component type, or a React fragment type.",
+      "type": "function",
+      "module": "react",
+      "url": "https://react.dev/reference/react/createElement"
+    },
+    "cloneElement": {
+      "signature": "function cloneElement(element: ReactElement, props?: object, ...children: ReactNode[]): ReactElement",
+      "description": "Clone and return a new React element using element as the starting point. props are shallowly merged. New children replace existing children.",
+      "type": "function",
+      "module": "react",
+      "url": "https://react.dev/reference/react/cloneElement"
+    },
+    "createContext": {
+      "signature": "function createContext<T>(defaultValue: T): Context<T>",
+      "description": "Creates a Context object. When React renders a component that subscribes to this Context object, it will read the current context value from the closest matching Provider above it in the tree.",
+      "type": "function",
+      "module": "react",
+      "url": "https://react.dev/reference/react/createContext"
+    },
+    "forwardRef": {
+      "signature": "function forwardRef<T, P = {}>(render: ForwardRefRenderFunction<T, P>): ForwardRefExoticComponent<PropsWithoutRef<P> & RefAttributes<T>>",
+      "description": "Creates a React component that forwards the ref attribute it receives to another component below in the tree. Allows parent components to get direct access to a child DOM element or component instance.",
+      "type": "function",
+      "module": "react",
+      "url": "https://react.dev/reference/react/forwardRef"
+    },
+    "lazy": {
+      "signature": "function lazy<T extends ComponentType<any>>(factory: () => Promise<{ default: T }>): LazyExoticComponent<T>",
+      "description": "Lets you define a component that is loaded dynamically. This helps reduce the bundle size by splitting code that is not needed during the initial render. Must be used with Suspense.",
+      "type": "function",
+      "module": "react",
+      "url": "https://react.dev/reference/react/lazy"
+    },
+    "memo": {
+      "signature": "function memo<P extends object>(Component: FunctionComponent<P>, propsAreEqual?: (prevProps: Readonly<P>, nextProps: Readonly<P>) => boolean): NamedExoticComponent<P>",
+      "description": "Higher order component that lets you skip re-rendering a component when its props are unchanged. Wraps a component and returns a memoized version. React will skip rendering the wrapped component if its props have not changed.",
+      "type": "function",
+      "module": "react",
+      "url": "https://react.dev/reference/react/memo"
+    },
+    "startTransition": {
+      "signature": "function startTransition(scope: () => void): void",
+      "description": "Lets you update state without blocking the UI. Marks the state updates inside the callback as transitions, so React can interrupt them with more urgent updates.",
+      "type": "function",
+      "module": "react",
+      "url": "https://react.dev/reference/react/startTransition"
+    },
+    "createPortal": {
+      "signature": "function createPortal(children: ReactNode, container: Element | DocumentFragment, key?: string): ReactPortal",
+      "description": "Creates a portal to render children into a different part of the DOM. The portal still behaves like a normal React child in every other way — context, events, etc.",
+      "type": "function",
+      "module": "react-dom",
+      "url": "https://react.dev/reference/react-dom/createPortal"
+    },
+    "createRoot": {
+      "signature": "function createRoot(container: Element | DocumentFragment, options?: RootOptions): Root",
+      "description": "Creates a React root for displaying content inside a browser DOM element. The React 18+ way to render. After creating a root, call root.render() to display a React component inside it.",
+      "type": "function",
+      "module": "react-dom/client",
+      "url": "https://react.dev/reference/react-dom/client/createRoot"
+    },
+    "hydrateRoot": {
+      "signature": "function hydrateRoot(container: Element | Document, initialChildren: ReactNode, options?: HydrateRootOptions): Root",
+      "description": "Lets you display React components inside a browser DOM node whose HTML content was previously generated by react-dom/server. Used for server-side rendering hydration.",
+      "type": "function",
+      "module": "react-dom/client",
+      "url": "https://react.dev/reference/react-dom/client/hydrateRoot"
+    },
+    "flushSync": {
+      "signature": "function flushSync<R>(fn: () => R): R",
+      "description": "Forces React to flush any pending state updates inside the provided callback synchronously. This ensures the DOM is updated immediately. Use sparingly as it can hurt performance.",
+      "type": "function",
+      "module": "react-dom",
+      "url": "https://react.dev/reference/react-dom/flushSync"
+    },
+    "Fragment": {
+      "signature": "<Fragment>...</Fragment> or <>...</>",
+      "description": "Lets you group elements without a wrapper node. Useful when you need to return multiple elements from a component without adding extra nodes to the DOM.",
+      "type": "keyword",
+      "module": "react",
+      "url": "https://react.dev/reference/react/Fragment"
+    },
+    "StrictMode": {
+      "signature": "<StrictMode>...</StrictMode>",
+      "description": "Lets you find common bugs in your components early during development. Enables additional development-only checks: components will re-render an extra time, effects will run an extra time, and deprecated APIs are checked.",
+      "type": "keyword",
+      "module": "react",
+      "url": "https://react.dev/reference/react/StrictMode"
+    },
+    "Suspense": {
+      "signature": "<Suspense fallback={<Loading />}>...</Suspense>",
+      "description": "Lets you display a fallback while its children are loading. Useful for code splitting with React.lazy() and data fetching frameworks that integrate with Suspense.",
+      "type": "keyword",
+      "module": "react",
+      "url": "https://react.dev/reference/react/Suspense"
+    },
+    "Profiler": {
+      "signature": "<Profiler id=\"name\" onRender={callback}>...</Profiler>",
+      "description": "Lets you measure rendering performance of a React tree programmatically. The onRender callback receives information about what was rendered and how long it took.",
+      "type": "keyword",
+      "module": "react",
+      "url": "https://react.dev/reference/react/Profiler"
+    },
+    "Component": {
+      "signature": "class Component<P = {}, S = {}, SS = any> extends React.Component<P, S, SS>",
+      "description": "Base class for React components defined using ES6 classes. Class components have lifecycle methods, state, and refs. Function components with hooks are now preferred.",
+      "type": "class",
+      "module": "react",
+      "url": "https://react.dev/reference/react/Component"
+    },
+    "PureComponent": {
+      "signature": "class PureComponent<P = {}, S = {}, SS = any> extends React.PureComponent<P, S, SS>",
+      "description": "Similar to React.Component but implements shouldComponentUpdate() with a shallow prop and state comparison. Use React.memo for function components instead.",
+      "type": "class",
+      "module": "react",
+      "url": "https://react.dev/reference/react/PureComponent"
+    },
+    "Children": {
+      "signature": "React.Children",
+      "description": "Provides utilities for dealing with the opaque data structure of this.props.children. Includes map, forEach, count, only, and toArray methods.",
+      "type": "module",
+      "module": "react",
+      "url": "https://react.dev/reference/react/Children"
+    },
+    "Children.map": {
+      "signature": "function Children.map(children: ReactNode, fn: (child: ReactNode, index: number) => ReactNode): ReactNode[]",
+      "description": "Invokes a function on every immediate child. If children is an array, it will be traversed and the function will be called for each child in the array.",
+      "type": "method",
+      "module": "react",
+      "url": "https://react.dev/reference/react/Children#children-map"
+    },
+    "Children.forEach": {
+      "signature": "function Children.forEach(children: ReactNode, fn: (child: ReactNode, index: number) => void): void",
+      "description": "Like React.Children.map() but does not return an array. Iterates over the immediate children calling the provided function for each.",
+      "type": "method",
+      "module": "react",
+      "url": "https://react.dev/reference/react/Children#children-foreach"
+    },
+    "Children.count": {
+      "signature": "function Children.count(children: ReactNode): number",
+      "description": "Returns the total number of components in children, equal to the number of times the callback passed to map or forEach would be invoked.",
+      "type": "method",
+      "module": "react",
+      "url": "https://react.dev/reference/react/Children#children-count"
+    },
+    "Children.only": {
+      "signature": "function Children.only(children: ReactNode): ReactElement",
+      "description": "Verifies that children has only one child (a React element) and returns it. Otherwise this method throws an error.",
+      "type": "method",
+      "module": "react",
+      "url": "https://react.dev/reference/react/Children#children-only"
+    },
+    "Children.toArray": {
+      "signature": "function Children.toArray(children: ReactNode): ReactNode[]",
+      "description": "Returns the children opaque data structure as a flat array with keys assigned to each child. Useful to manipulate collections of children in render methods.",
+      "type": "method",
+      "module": "react",
+      "url": "https://react.dev/reference/react/Children#children-toarray"
+    },
+    "isValidElement": {
+      "signature": "function isValidElement(object: any): object is ReactElement",
+      "description": "Verifies the object is a valid React element. Returns true if the object is a React element created by createElement, JSX, or cloneElement.",
+      "type": "function",
+      "module": "react",
+      "url": "https://react.dev/reference/react/isValidElement"
+    },
+    "cache": {
+      "signature": "function cache<T extends Function>(fn: T): T",
+      "description": "Wraps a function to cache its result. When the cached function is called with the same arguments, it returns the cached result. Primarily for React Server Components.",
+      "type": "function",
+      "module": "react",
+      "url": "https://react.dev/reference/react/cache"
+    },
+    "experimental_taintObjectReference": {
+      "signature": "function experimental_taintObjectReference(message: string, object: object): void",
+      "description": "Prevents a specific object instance from being passed to a Client Component. Used for security in Server Components to prevent sensitive data from leaking to the client.",
+      "type": "function",
+      "module": "react",
+      "url": "https://react.dev/reference/react/experimental_taintObjectReference"
+    },
+    "renderToString": {
+      "signature": "function renderToString(element: ReactElement): string",
+      "description": "Renders a React tree to an HTML string. Used for server-side rendering. On the client, call hydrateRoot to make the server-generated HTML interactive.",
+      "type": "function",
+      "module": "react-dom/server",
+      "url": "https://react.dev/reference/react-dom/server/renderToString"
+    },
+    "renderToStaticMarkup": {
+      "signature": "function renderToStaticMarkup(element: ReactElement): string",
+      "description": "Renders a non-interactive React tree to an HTML string. The output cannot be hydrated. Used for generating static HTML content.",
+      "type": "function",
+      "module": "react-dom/server",
+      "url": "https://react.dev/reference/react-dom/server/renderToStaticMarkup"
+    },
+    "renderToPipeableStream": {
+      "signature": "function renderToPipeableStream(element: ReactNode, options?: RenderToPipeableStreamOptions): PipeableStream",
+      "description": "Renders a React tree to a pipeable Node.js Stream. Supports streaming with Suspense. The recommended server rendering API for Node.js environments.",
+      "type": "function",
+      "module": "react-dom/server",
+      "url": "https://react.dev/reference/react-dom/server/renderToPipeableStream"
+    },
+    "renderToReadableStream": {
+      "signature": "function renderToReadableStream(element: ReactNode, options?: RenderToReadableStreamOptions): Promise<ReadableStream>",
+      "description": "Renders a React tree to a Readable Web Stream. Supports streaming with Suspense. For Web Stream environments like Deno and edge runtimes.",
+      "type": "function",
+      "module": "react-dom/server",
+      "url": "https://react.dev/reference/react-dom/server/renderToReadableStream"
+    },
+    "preload": {
+      "signature": "function preload(href: string, options: PreloadOptions): void",
+      "description": "Lets you eagerly fetch a resource such as a stylesheet, font, or external script that you expect to use.",
+      "type": "function",
+      "module": "react-dom",
+      "url": "https://react.dev/reference/react-dom/preload"
+    },
+    "prefetchDNS": {
+      "signature": "function prefetchDNS(href: string): void",
+      "description": "Lets you eagerly look up the IP of a server that you expect to load resources from.",
+      "type": "function",
+      "module": "react-dom",
+      "url": "https://react.dev/reference/react-dom/prefetchDNS"
+    },
+    "preconnect": {
+      "signature": "function preconnect(href: string, options?: PreconnectOptions): void",
+      "description": "Lets you eagerly connect to a server that you expect to load resources from.",
+      "type": "function",
+      "module": "react-dom",
+      "url": "https://react.dev/reference/react-dom/preconnect"
+    },
+    "preinit": {
+      "signature": "function preinit(href: string, options: PreinitOptions): void",
+      "description": "Lets you eagerly fetch and evaluate a stylesheet or external script.",
+      "type": "function",
+      "module": "react-dom",
+      "url": "https://react.dev/reference/react-dom/preinit"
+    },
+    "act": {
+      "signature": "function act(callback: () => void | Promise<void>): Promise<void>",
+      "description": "Wraps code that causes React state updates so that you can make assertions about the resulting state. Used primarily in testing to ensure all updates have been processed.",
+      "type": "function",
+      "module": "react",
+      "url": "https://react.dev/reference/react/act"
+    },
+    "unmountComponentAtNode": {
+      "signature": "function unmountComponentAtNode(container: Element): boolean",
+      "description": "Removes a mounted React component from the DOM and cleans up its event handlers and state. Legacy API — use root.unmount() with createRoot instead.",
+      "type": "function",
+      "module": "react-dom",
+      "url": "https://react.dev/reference/react-dom/unmountComponentAtNode"
+    },
+    "findDOMNode": {
+      "signature": "function findDOMNode(instance: Component): Element | null",
+      "description": "Finds the DOM node for the given class component instance. Legacy API — use refs instead. This API is not supported in StrictMode.",
+      "type": "function",
+      "module": "react-dom",
+      "url": "https://react.dev/reference/react-dom/findDOMNode"
+    }
+  }
+}