acrylblends 0.8.1 → 0.9.0

package/plugins/acryl-router/src/core/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @module
+ *
+ * Acryl - Web Framework built on Web Standards
+ *
+ * @example
+ * ```ts
+ * import { Acryl } from 'acrylblends'
+ * const app = new Acryl()
+ *
+ * app.get('/', (c) => c.text('Acryl!'))
+ *
+ * export default app
+ * ```
+ */
+import { Acryl } from './app.ts';
+/**
+ * Types for environment variables, error handlers, handlers, middleware handlers, and more.
+ */
+export type { Env, ErrorHandler, Handler, MiddlewareHandler, Next, NotFoundResponse, NotFoundHandler, ValidationTargets, Input, Schema, ToSchema, TypedResponse, } from './types.ts';
+/**
+ * Types for context, context variable map, context renderer, and execution context.
+ */
+export { Context } from './context.ts';
+export type { ContextVariableMap, ContextRenderer, ExecutionContext } from './context.ts';
+/**
+ * Type for AcrylRequest.
+ */
+export type { AcrylRequest } from './request.ts';
+/**
+ * Types for inferring request and response types and client request options.
+ */
+export type { InferRequestType, InferResponseType, ClientRequestOptions } from './client/index.ts';
+/**
+ * Acryl framework for building web applications.
+ */
+export { Acryl };

package/plugins/acryl-router/src/core/jsx/base.d.ts

@@ -0,0 +1,61 @@
+import type { HtmlEscaped, HtmlEscapedString, StringBufferWithCallbacks } from '../utils/html.ts';
+import { DOM_MEMO } from './constants.ts';
+import type { Context } from './context.ts';
+import type { JSX as AcrylJSX } from './intrinsic-elements.ts';
+export type Props = Record<string, any>;
+type FunctionComponentResult = HtmlEscapedString | JSXNode | Child[] | Promise<HtmlEscapedString | JSXNode | Child[]> | null;
+export type FC<P = Props> = {
+    (props: P): FunctionComponentResult;
+    defaultProps?: Partial<P> | undefined;
+    displayName?: string | undefined;
+};
+export type DOMAttributes = AcrylJSX.HTMLAttributes;
+export declare namespace JSX {
+    type Element = HtmlEscapedString | Promise<HtmlEscapedString>;
+    type ElementType = string | ((props: never) => FunctionComponentResult);
+    interface ElementChildrenAttribute {
+        children: Child;
+    }
+    interface IntrinsicElements extends AcrylJSX.IntrinsicElements {
+        [tagName: string]: Props;
+    }
+    interface IntrinsicAttributes {
+        key?: string | number | bigint | null | undefined;
+    }
+}
+export declare const getNameSpaceContext: () => Context<string> | undefined;
+export declare const booleanAttributes: string[];
+export type Child = string | Promise<string> | number | JSXNode | null | undefined | boolean | Child[];
+export declare const renderChildren: (children: Child[]) => HtmlEscapedString | Promise<HtmlEscapedString>;
+export declare const isUntrustedObject: (value: unknown) => boolean;
+export declare const renderUntrustedObject: (value: unknown) => HtmlEscapedString | Promise<HtmlEscapedString>;
+export declare class JSXNode implements HtmlEscaped {
+    tag: string | Function;
+    props: Props;
+    key?: string;
+    children: Child[];
+    isEscaped: true;
+    constructor(tag: string | Function, props: Props, children: Child[]);
+    get type(): string | Function;
+    get ref(): any;
+    toString(): string | Promise<string>;
+    toStringToBuffer(buffer: StringBufferWithCallbacks): void;
+}
+export declare class JSXFragmentNode extends JSXNode {
+    toStringToBuffer(buffer: StringBufferWithCallbacks): void;
+}
+export declare const jsx: (tag: string | Function, props: Props | null, ...children: Child[]) => JSXNode;
+export declare const jsxFn: (tag: string | Function, props: Props, children: Child[]) => JSXNode;
+export declare const shallowEqual: (a: Props, b: Props) => boolean;
+export type MemorableFC<T> = FC<T> & {
+    [DOM_MEMO]: (prevProps: Readonly<T>, nextProps: Readonly<T>) => boolean;
+};
+export declare const memo: <T>(component: FC<T>, propsAreEqual?: (prevProps: Readonly<T>, nextProps: Readonly<T>) => boolean) => FC<T>;
+export declare const Fragment: ({ children, }: {
+    key?: string;
+    children?: Child | HtmlEscapedString;
+}) => HtmlEscapedString;
+export declare const isValidElement: (element: unknown) => element is JSXNode;
+export declare const cloneElement: <T extends JSXNode | JSX.Element>(element: T, props: Partial<Props>, ...children: Child[]) => T;
+export declare const reactAPICompatVersion = "19.0.0-acryl-jsx";
+export {};

package/plugins/acryl-router/src/core/jsx/children.d.ts

@@ -0,0 +1,9 @@
+import type { Child } from './base.ts';
+export declare const toArray: (children: Child) => Child[];
+export declare const Children: {
+    map: (children: Child[], fn: (child: Child, index: number) => Child) => Child[];
+    forEach: (children: Child[], fn: (child: Child, index: number) => void) => void;
+    count: (children: Child[]) => number;
+    only: (_children: Child[]) => Child;
+    toArray: (children: Child) => Child[];
+};

package/plugins/acryl-router/src/core/jsx/components.d.ts

@@ -0,0 +1,15 @@
+import type { HtmlEscapedString } from '../utils/html.ts';
+import type { Child, FC, PropsWithChildren } from './index.ts';
+export declare const childrenToString: (children: Child[]) => Promise<HtmlEscapedString[]>;
+export type ErrorHandler = (error: Error) => void;
+export type FallbackRender = (error: Error) => Child;
+/**
+ * @experimental
+ * `ErrorBoundary` is an experimental feature.
+ * The API might be changed.
+ */
+export declare const ErrorBoundary: FC<PropsWithChildren<{
+    fallback?: Child;
+    fallbackRender?: FallbackRender;
+    onError?: ErrorHandler;
+}>>;

package/plugins/acryl-router/src/core/jsx/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const DOM_RENDERER: unique symbol;
+export declare const DOM_ERROR_HANDLER: unique symbol;
+export declare const DOM_STASH: unique symbol;
+export declare const DOM_INTERNAL_TAG: unique symbol;
+export declare const DOM_MEMO: unique symbol;
+export declare const PERMALINK: unique symbol;

package/plugins/acryl-router/src/core/jsx/context.d.ts

@@ -0,0 +1,51 @@
+import type { FC, PropsWithChildren } from './index.ts';
+export interface Context<T> extends FC<PropsWithChildren<{
+    value: T;
+}>> {
+    values: T[];
+    Provider: FC<PropsWithChildren<{
+        value: T;
+    }>>;
+}
+export declare const globalContexts: Context<unknown>[];
+/** Per-render context store, isolated per request so values never leak across renders. */
+type RenderStore = WeakMap<Context<unknown>, unknown[]>;
+/**
+ * Establish the request-scoped context store for a render.
+ *
+ * `resumeStore` continues a suspended subtree in the same store on the fallback
+ * path (ignored when `AsyncLocalStorage` is available, where isolation is
+ * automatic).
+ *
+ * Without `AsyncLocalStorage` a render can't be followed across `await`, so the
+ * store lives in `fallbackStore` only during synchronous work (mirroring
+ * React's request storage). Reading context after `await` then finds no store
+ * and falls back to the default value — never another request's value.
+ */
+export declare const runWithRenderContext: <T>(callback: () => T, resumeStore?: RenderStore) => T;
+/**
+ * Capture the current render store and return a resumer that re-establishes it
+ * around a deferred continuation (e.g. a re-render after a suspended promise
+ * settles). Shared by every suspension point so none reimplements it.
+ */
+export declare const captureRenderContext: () => (<T>(callback: () => T) => T);
+/**
+ * Create a context whose value can be provided with `<Context.Provider>` and
+ * read with {@link useContext}.
+ *
+ * Server-side renders are isolated per request, so a provided value never leaks
+ * into a concurrent request — even across `await` in an async component, when
+ * `AsyncLocalStorage` is available (Node.js >= 20.16, Deno, Bun, Cloudflare
+ * Workers with `nodejs_compat`). Without it, reading context after `await`
+ * returns the default value; synchronous components and `use()`-based
+ * suspension are unaffected.
+ */
+export declare const createContext: <T>(defaultValue: T) => Context<T>;
+/**
+ * Read the current value of a context created with {@link createContext}.
+ *
+ * Safe to call from async components after `await`. See {@link createContext}
+ * for the per-runtime isolation guarantees.
+ */
+export declare const useContext: <T>(context: Context<T>) => T;
+export {};

package/plugins/acryl-router/src/core/jsx/dom/components.d.ts

@@ -0,0 +1,10 @@
+import type { Child, FC, PropsWithChildren } from '../index.ts';
+import type { ErrorHandler, FallbackRender } from '../components.ts';
+export declare const ErrorBoundary: FC<PropsWithChildren<{
+    fallback?: Child;
+    fallbackRender?: FallbackRender;
+    onError?: ErrorHandler;
+}>>;
+export declare const Suspense: FC<PropsWithChildren<{
+    fallback: any;
+}>>;

package/plugins/acryl-router/src/core/jsx/dom/context.d.ts

@@ -0,0 +1,3 @@
+import type { Context } from '../context.ts';
+export declare const createContextProviderFunction: <T>(values: T[]) => Function;
+export declare const createContext: <T>(defaultValue: T) => Context<T>;

package/plugins/acryl-router/src/core/jsx/dom/css.d.ts

@@ -0,0 +1,83 @@
+/**
+ * @module
+ * This module provides APIs that enable `acryl-router/jsx/dom` to support.
+ */
+import type { FC, PropsWithChildren } from '../index.ts';
+import type { ClassNameSlug, CssClassName, CssVariableType, OnInvalidSlug } from '../../helper/css/common.ts';
+export { rawCssString } from '../../helper/css/common.ts';
+interface CreateCssJsxDomObjectsType {
+    (args: {
+        id: Readonly<string>;
+    }): readonly [
+        {
+            toString(this: CssClassName): string;
+        },
+        FC<PropsWithChildren<void>>
+    ];
+}
+export declare const createCssJsxDomObjects: CreateCssJsxDomObjectsType;
+interface CssType {
+    (strings: TemplateStringsArray, ...values: CssVariableType[]): string;
+}
+interface CxType {
+    (...args: (string | boolean | null | undefined)[]): string;
+}
+interface KeyframesType {
+    (strings: TemplateStringsArray, ...values: CssVariableType[]): CssClassName;
+}
+interface ViewTransitionType {
+    (strings: TemplateStringsArray, ...values: CssVariableType[]): string;
+    (content: string): string;
+    (): string;
+}
+interface DefaultContextType {
+    css: CssType;
+    cx: CxType;
+    keyframes: KeyframesType;
+    viewTransition: ViewTransitionType;
+    Style: FC<PropsWithChildren<void>>;
+}
+/**
+ * @experimental
+ * `createCssContext` is an experimental feature.
+ * The API might be changed.
+ *
+ * @param options.id - The ID for the style element
+ * @param options.classNameSlug - Optional function to customize generated CSS class names
+ * @param options.onInvalidSlug - Optional callback function called when an invalid slug is returned from ClassNameSlug
+ */
+export declare const createCssContext: ({ id, classNameSlug, onInvalidSlug, }: {
+    id: Readonly<string>;
+    classNameSlug?: ClassNameSlug;
+    onInvalidSlug?: OnInvalidSlug;
+}) => DefaultContextType;
+/**
+ * @experimental
+ * `css` is an experimental feature.
+ * The API might be changed.
+ */
+export declare const css: CssType;
+/**
+ * @experimental
+ * `cx` is an experimental feature.
+ * The API might be changed.
+ */
+export declare const cx: CxType;
+/**
+ * @experimental
+ * `keyframes` is an experimental feature.
+ * The API might be changed.
+ */
+export declare const keyframes: KeyframesType;
+/**
+ * @experimental
+ * `viewTransition` is an experimental feature.
+ * The API might be changed.
+ */
+export declare const viewTransition: ViewTransitionType;
+/**
+ * @experimental
+ * `Style` is an experimental feature.
+ * The API might be changed.
+ */
+export declare const Style: FC<PropsWithChildren<void>>;

package/plugins/acryl-router/src/core/jsx/dom/hooks/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Provide hooks used only in jsx/dom
+ */
+import type { Context } from '../../context.ts';
+type FormStatus = {
+    pending: false;
+    data: null;
+    method: null;
+    action: null;
+} | {
+    pending: true;
+    data: FormData;
+    method: 'get' | 'post';
+    action: string | ((formData: FormData) => void | Promise<void>);
+};
+export declare const FormContext: Context<FormStatus>;
+export declare const registerAction: (action: Promise<unknown>) => void;
+/**
+ * This hook returns the current form status
+ * @returns FormStatus
+ */
+export declare const useFormStatus: () => FormStatus;
+/**
+ * This hook returns the current state and a function to update the state optimistically
+ * The current state is updated optimistically and then reverted to the original state when all actions are resolved
+ * @param state
+ * @param updateState
+ * @returns [T, (action: N) => void]
+ */
+export declare const useOptimistic: <T, N>(state: T, updateState: (currentState: T, action: N) => T) => [T, (action: N) => void];
+/**
+ * This hook returns the current state and a function to update the state by form action
+ * @param fn
+ * @param initialState
+ * @param permalink
+ * @returns [T, (data: FormData) => void]
+ */
+export declare const useActionState: <T>(fn: Function, initialState: T, permalink?: string) => [T, Function];
+export {};

package/plugins/acryl-router/src/core/jsx/dom/intrinsic-element/components.d.ts

@@ -0,0 +1,16 @@
+import type { IntrinsicElements } from '../../intrinsic-elements.ts';
+import type { FC, PropsWithChildren, RefObject } from '../../types.ts';
+export declare const clearCache: () => void;
+export declare const composeRef: <T>(ref: RefObject<T | null> | Function | undefined, cb: (e: T) => void | (() => void)) => ((e: T) => () => void);
+export declare const title: FC<PropsWithChildren>;
+export declare const script: FC<PropsWithChildren<IntrinsicElements['script']>>;
+export declare const style: FC<PropsWithChildren<IntrinsicElements['style']>>;
+export declare const link: FC<PropsWithChildren<IntrinsicElements['link']>>;
+export declare const meta: FC<PropsWithChildren>;
+export declare const form: FC<PropsWithChildren<{
+    action?: Function | string;
+    method?: 'get' | 'post';
+    ref?: RefObject<HTMLFormElement | null> | ((e: HTMLFormElement | null) => void | (() => void));
+}>>;
+export declare const input: FC<PropsWithChildren<IntrinsicElements['input']>>;
+export declare const button: FC<PropsWithChildren<IntrinsicElements['button']>>;

package/plugins/acryl-router/src/core/jsx/dom/jsx-dev-runtime.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @module
+ * This module provides the `acryl-router/jsx/dom` dev runtime.
+ */
+import type { JSXNode, Props } from '../base.ts';
+export type { JSX } from '../base.ts';
+export declare const jsxDEV: (tag: string | Function, props: Props, key?: string) => JSXNode;
+export declare const Fragment: (props: Record<string, unknown>) => JSXNode;

package/plugins/acryl-router/src/core/jsx/dom/jsx-runtime.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @module
+ * This module provides the `acryl-router/jsx/dom` runtime.
+ */
+export { jsxDEV as jsx, Fragment } from './jsx-dev-runtime.ts';
+export { jsxDEV as jsxs } from './jsx-dev-runtime.ts';
+export type { JSX } from './jsx-dev-runtime.ts';

package/plugins/acryl-router/src/core/jsx/dom/render.d.ts

@@ -0,0 +1,73 @@
+import type { Child, FC, JSXNode, Props } from '../base.ts';
+import { DOM_RENDERER, DOM_STASH } from '../constants.ts';
+import type { Context as JSXContext } from '../context.ts';
+export type HasRenderToDom = FC<any> & {
+    [DOM_RENDERER]: FC<any>;
+};
+export type ErrorHandler = (error: any, retry: () => void) => Child | undefined;
+type Container = HTMLElement | DocumentFragment;
+type LocalJSXContexts = [JSXContext<unknown>, unknown][] | undefined;
+type SupportedElement = HTMLElement | SVGElement | MathMLElement;
+export type PreserveNodeType = 1 | 2;
+export type NodeObject = {
+    pP: Props | undefined;
+    nN: Node | undefined;
+    vC: Node[];
+    pC?: Node[];
+    vR: Node[];
+    n?: string;
+    f?: boolean;
+    s?: boolean;
+    c: Container | undefined;
+    e: SupportedElement | Text | undefined;
+    p?: PreserveNodeType;
+    a?: boolean;
+    o?: NodeObject;
+    [DOM_STASH]: [
+        number,
+        any[][],
+        LocalJSXContexts,
+        [
+            Context,
+            Function,
+            NodeObject
+        ]
+    ] | [number, any[][]];
+} & JSXNode;
+type NodeString = {
+    t: string;
+    d: boolean;
+    s?: boolean;
+} & {
+    e?: Text;
+    vC: undefined;
+    nN: undefined;
+    p?: true;
+    key: undefined;
+    tag: undefined;
+};
+export type Node = NodeString | NodeObject;
+export type PendingType = 0 | 1 | 2;
+export type UpdateHook = (context: Context, node: Node, cb: (context: Context) => void) => Promise<void>;
+export type Context = [
+    PendingType,
+    boolean,
+    UpdateHook,
+    boolean,
+    boolean,
+    [
+        Context,
+        Function,
+        NodeObject
+    ][]
+] | [PendingType, boolean, UpdateHook, boolean] | [PendingType, boolean, UpdateHook] | [PendingType, boolean] | [PendingType] | [];
+export declare const buildDataStack: [Context, Node][];
+export declare const getNameSpaceContext: () => JSXContext<string> | undefined;
+export declare const build: (context: Context, node: NodeObject, children?: Child[]) => void;
+export declare const buildNode: (node: Child) => Node | undefined;
+export declare const update: (context: Context, node: NodeObject) => Promise<NodeObject | undefined>;
+export declare const renderNode: (node: NodeObject, container: Container) => void;
+export declare const render: (jsxNode: Child, container: Container) => void;
+export declare const flushSync: (callback: () => void) => void;
+export declare const createPortal: (children: Child, container: HTMLElement, key?: string) => Child;
+export {};

package/plugins/acryl-router/src/core/jsx/dom/utils.d.ts

@@ -0,0 +1 @@
+export declare const setInternalTagFlag: (fn: Function) => Function;

package/plugins/acryl-router/src/core/jsx/hooks/index.d.ts

@@ -0,0 +1,47 @@
+import type { JSX } from '../base.ts';
+type UpdateStateFunction<T> = (newState: T | ((currentState: T) => T)) => void;
+export declare const STASH_EFFECT = 1;
+export type EffectData = [
+    readonly unknown[] | undefined,
+    // deps
+    (() => void | (() => void)) | undefined,
+    // layout effect
+    (() => void) | undefined,
+    // cleanup
+    (() => void) | undefined,
+    // effect
+    (() => void) | undefined
+];
+export declare const startViewTransition: (callback: () => void) => void;
+export declare const useViewTransition: () => [boolean, (callback: () => void) => void];
+export declare const startTransition: (callback: () => void) => void;
+export declare const useTransition: () => [boolean, (callback: () => void | Promise<void>) => void];
+type UseDeferredValue = <T>(value: T, initialValue?: T) => T;
+export declare const useDeferredValue: UseDeferredValue;
+type UseStateType = {
+    <T>(initialState: T | (() => T)): [T, UpdateStateFunction<T>];
+    <T = undefined>(): [T | undefined, UpdateStateFunction<T | undefined>];
+};
+export declare const useState: UseStateType;
+export declare const useReducer: <T, A>(reducer: (state: T, action: A) => T, initialArg: T, init?: (initialState: T) => T) => [T, (action: A) => void];
+export declare const useEffect: (effect: () => void | (() => void), deps?: readonly unknown[]) => void;
+export declare const useLayoutEffect: (effect: () => void | (() => void), deps?: readonly unknown[]) => void;
+export declare const useInsertionEffect: (effect: () => void | (() => void), deps?: readonly unknown[]) => void;
+export declare const useCallback: <T extends Function>(callback: T, deps: readonly unknown[]) => T;
+export type RefObject<T> = {
+    current: T;
+};
+export declare function useRef<T>(initialValue: T): RefObject<T>;
+export declare function useRef<T>(initialValue: T | null): RefObject<T | null>;
+export declare function useRef<T>(initialValue: T | undefined): RefObject<T | undefined>;
+export declare const use: <T>(promise: Promise<T>) => T;
+export declare const useMemo: <T>(factory: () => T, deps: readonly unknown[]) => T;
+export declare const useId: () => string;
+export declare const useDebugValue: (_value: unknown, _formatter?: (value: unknown) => string) => void;
+export declare const createRef: <T>() => RefObject<T | null>;
+export declare const forwardRef: <T, P = {}>(Component: (props: P, ref?: RefObject<T | null>) => JSX.Element) => ((props: P & {
+    ref?: RefObject<T | null>;
+}) => JSX.Element);
+export declare const useImperativeHandle: <T>(ref: RefObject<T | null>, createHandle: () => T, deps: readonly unknown[]) => void;
+export declare const useSyncExternalStore: <T>(subscribe: (callback: () => void) => () => void, getSnapshot: () => T, getServerSnapshot?: () => T) => T;
+export {};

package/plugins/acryl-router/src/core/jsx/index.d.ts

@@ -0,0 +1,76 @@
+/**
+ * @module
+ * JSX for Acryl.
+ */
+import { Fragment, cloneElement, isValidElement, jsx, memo, reactAPICompatVersion } from './base.ts';
+import type { DOMAttributes } from './base.ts';
+import { Children } from './children.ts';
+import { ErrorBoundary } from './components.ts';
+import { createContext, useContext } from './context.ts';
+import { useActionState, useOptimistic } from './dom/hooks/index.ts';
+import { createRef, forwardRef, startTransition, startViewTransition, use, useCallback, useDebugValue, useDeferredValue, useEffect, useId, useImperativeHandle, useInsertionEffect, useLayoutEffect, useMemo, useReducer, useRef, useState, useSyncExternalStore, useTransition, useViewTransition } from './hooks/index.ts';
+import { Suspense } from './streaming.ts';
+export { reactAPICompatVersion as version, jsx, memo, Fragment, Fragment as StrictMode, isValidElement, jsx as createElement, cloneElement, ErrorBoundary, createContext, useContext, useState, useEffect, useRef, useCallback, useReducer, useId, useDebugValue, use, startTransition, useTransition, useDeferredValue, startViewTransition, useViewTransition, useMemo, useLayoutEffect, useInsertionEffect, createRef, forwardRef, useImperativeHandle, useSyncExternalStore, useActionState, useOptimistic, Suspense, Children, };
+export type { DOMAttributes };
+declare const _default: {
+    version: string;
+    memo: <T>(component: import("./base.ts").FC<T>, propsAreEqual?: (prevProps: Readonly<T>, nextProps: Readonly<T>) => boolean) => import("./base.ts").FC<T>;
+    Fragment: ({ children, }: {
+        key?: string;
+        children?: import("./base.ts").Child | import("../utils/html.ts").HtmlEscapedString;
+    }) => import("../utils/html.ts").HtmlEscapedString;
+    StrictMode: ({ children, }: {
+        key?: string;
+        children?: import("./base.ts").Child | import("../utils/html.ts").HtmlEscapedString;
+    }) => import("../utils/html.ts").HtmlEscapedString;
+    isValidElement: (element: unknown) => element is import("./base.ts").JSXNode;
+    createElement: (tag: string | Function, props: import("./base.ts").Props | null, ...children: import("./base.ts").Child[]) => import("./base.ts").JSXNode;
+    cloneElement: <T extends import("./base.ts").JSXNode | import("./base.ts").JSX.Element>(element: T, props: Partial<import("./base.ts").Props>, ...children: import("./base.ts").Child[]) => T;
+    ErrorBoundary: import("./base.ts").FC<import("./types.ts").PropsWithChildren<{
+        fallback?: import("./base.ts").Child;
+        fallbackRender?: import("./components.ts").FallbackRender;
+        onError?: import("./components.ts").ErrorHandler;
+    }>>;
+    createContext: <T>(defaultValue: T) => import("./context.ts").Context<T>;
+    useContext: <T>(context: import("./context.ts").Context<T>) => T;
+    useState: {
+        <T>(initialState: T | (() => T)): [T, (newState: T | ((currentState: T) => T)) => void];
+        <T = undefined>(): [T | undefined, (newState: T | ((currentState: T | undefined) => T | undefined) | undefined) => void];
+    };
+    useEffect: (effect: () => void | (() => void), deps?: readonly unknown[]) => void;
+    useRef: typeof useRef;
+    useCallback: <T extends Function>(callback: T, deps: readonly unknown[]) => T;
+    useReducer: <T, A>(reducer: (state: T, action: A) => T, initialArg: T, init?: (initialState: T) => T) => [T, (action: A) => void];
+    useId: () => string;
+    useDebugValue: (_value: unknown, _formatter?: (value: unknown) => string) => void;
+    use: <T>(promise: Promise<T>) => T;
+    startTransition: (callback: () => void) => void;
+    useTransition: () => [boolean, (callback: () => void | Promise<void>) => void];
+    useDeferredValue: <T>(value: T, initialValue?: T) => T;
+    startViewTransition: (callback: () => void) => void;
+    useViewTransition: () => [boolean, (callback: () => void) => void];
+    useMemo: <T>(factory: () => T, deps: readonly unknown[]) => T;
+    useLayoutEffect: (effect: () => void | (() => void), deps?: readonly unknown[]) => void;
+    useInsertionEffect: (effect: () => void | (() => void), deps?: readonly unknown[]) => void;
+    createRef: <T>() => import("./types.ts").RefObject<T | null>;
+    forwardRef: <T, P = {}>(Component: (props: P, ref?: import("./types.ts").RefObject<T | null>) => import("./base.ts").JSX.Element) => ((props: P & {
+        ref?: import("./types.ts").RefObject<T | null>;
+    }) => import("./base.ts").JSX.Element);
+    useImperativeHandle: <T>(ref: import("./types.ts").RefObject<T | null>, createHandle: () => T, deps: readonly unknown[]) => void;
+    useSyncExternalStore: <T>(subscribe: (callback: () => void) => () => void, getSnapshot: () => T, getServerSnapshot?: () => T) => T;
+    useActionState: <T>(fn: Function, initialState: T, permalink?: string) => [T, Function];
+    useOptimistic: <T, N>(state: T, updateState: (currentState: T, action: N) => T) => [T, (action: N) => void];
+    Suspense: import("./base.ts").FC<import("./types.ts").PropsWithChildren<{
+        fallback: any;
+    }>>;
+    Children: {
+        map: (children: import("./base.ts").Child[], fn: (child: import("./base.ts").Child, index: number) => import("./base.ts").Child) => import("./base.ts").Child[];
+        forEach: (children: import("./base.ts").Child[], fn: (child: import("./base.ts").Child, index: number) => void) => void;
+        count: (children: import("./base.ts").Child[]) => number;
+        only: (_children: import("./base.ts").Child[]) => import("./base.ts").Child;
+        toArray: (children: import("./base.ts").Child) => import("./base.ts").Child[];
+    };
+};
+export default _default;
+export type * from './types.ts';
+export type { JSX } from './intrinsic-elements.ts';

package/plugins/acryl-router/src/core/jsx/intrinsic-element/common.d.ts

@@ -0,0 +1,6 @@
+import type { Props } from '../base.ts';
+export declare const deDupeKeyMap: Record<string, string[]>;
+export declare const domRenderers: Record<string, Function>;
+export declare const dataPrecedenceAttr = "data-precedence";
+export declare const isStylesheetLinkWithPrecedence: (props: Props) => boolean;
+export declare const shouldDeDupeByKey: (tagName: string, supportSort: boolean) => boolean;

package/plugins/acryl-router/src/core/jsx/intrinsic-element/components.d.ts

@@ -0,0 +1,13 @@
+import type { IntrinsicElements } from '../intrinsic-elements.ts';
+import type { FC, PropsWithChildren } from '../types.ts';
+export declare const title: FC<PropsWithChildren>;
+export declare const script: FC<PropsWithChildren<IntrinsicElements['script']>>;
+export declare const style: FC<PropsWithChildren<IntrinsicElements['style']>>;
+export declare const link: FC<PropsWithChildren<IntrinsicElements['link']>>;
+export declare const meta: FC<PropsWithChildren>;
+export declare const form: FC<PropsWithChildren<{
+    action?: Function | string;
+    method?: 'get' | 'post';
+}>>;
+export declare const input: (props: PropsWithChildren) => unknown;
+export declare const button: (props: PropsWithChildren) => unknown;