@faasjs/react 5.0.0-beta.1 → 5.0.0-beta.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@faasjs/react",
-  "version": "5.0.0-beta.1",
+  "version": "5.0.0-beta.3",
   "license": "MIT",
   "type": "module",
   "main": "dist/index.js",
@@ -9,7 +9,7 @@
   "exports": {
     ".": {
       "import": {
-        "types": "./dist/index.d.mts",
+        "types": "./dist/index.d.ts",
         "default": "./dist/index.mjs"
       },
       "require": {
@@ -35,10 +35,10 @@
     "dist"
   ],
   "peerDependencies": {
-    "@faasjs/browser": "5.0.0-beta.1"
+    "@faasjs/browser": "5.0.0-beta.3"
   },
   "devDependencies": {
-    "@faasjs/browser": "5.0.0-beta.1",
+    "@faasjs/browser": "5.0.0-beta.3",
     "@types/react": "*",
     "react": "*"
   },

package/dist/index.d.cts

@@ -1,629 +0,0 @@
-import { FaasAction, FaasData, FaasParams } from '@faasjs/types';
-export { FaasAction, FaasData, FaasParams } from '@faasjs/types';
-import { Response, BaseUrl, ResponseError, Options, FaasBrowserClient } from '@faasjs/browser';
-export { Options, Response, ResponseError, ResponseHeaders } from '@faasjs/browser';
-import * as react from 'react';
-import { ReactNode, Dispatch, SetStateAction, RefObject, JSX, ReactElement, Component, ComponentType, ComponentProps, JSXElementConstructor } from 'react';
-import * as react_jsx_runtime from 'react/jsx-runtime';
-
-/**
- * Returns a constant value that is created by the given function.
- */
-declare function useConstant<T>(fn: () => T): T;
-declare namespace useConstant {
-    var whyDidYouRender: boolean;
-}
-
-/**
- * Compares two values for deep equality.
- *
- * This function checks if two values are deeply equal by comparing their types and contents.
- * It handles various data types including primitives, arrays, dates, regular expressions, functions,
- * maps, sets, and promises.
- *
- * @param a - The first value to compare.
- * @param b - The second value to compare.
- * @returns `true` if the values are deeply equal, `false` otherwise.
- */
-declare function equal(a: any, b: any): boolean;
-/**
- * Custom hook that memoizes a value using deep equality comparison.
- *
- * @param value - The value to be memoized.
- * @returns The memoized value.
- */
-declare function useEqualMemoize(value: any): any;
-/**
- * Custom hook that works like `useEffect` but uses deep comparison on dependencies.
- *
- * @param callback - The effect callback function to run.
- * @param dependencies - The list of dependencies for the effect.
- * @returns The result of the `useEffect` hook with memoized dependencies.
- */
-declare function useEqualEffect(callback: React.EffectCallback, dependencies: any[]): void;
-/**
- * Custom hook that works like `useMemo` but uses deep comparison on dependencies.
- *
- * @param callback - The callback function to run.
- * @param dependencies - The list of dependencies.
- * @returns The result of the `useMemo` hook with memoized dependencies.
- */
-declare function useEqualMemo<T>(callback: () => T, dependencies: any[]): T;
-/**
- * Custom hook that works like `useCallback` but uses deep comparison on dependencies.
- *
- * @param callback - The callback function to run.
- * @param dependencies - The list of dependencies.
- * @returns The result of the `useCallback` hook with memoized dependencies.
- */
-declare function useEqualCallback<T extends (...args: any[]) => any>(callback: T, dependencies: any[]): T;
-
-/**
- * Creates a splitting context with the given default value.
- *
- * @param defaultValue The default value of the splitting context.
- *
- * @example
- * ```tsx
- * const { Provider, use } = createSplittingContext<{
- *   value: number
- *   setValue: React.Dispatch<React.SetStateAction<number>>
- * }>({
- *   value: 0,
- *   setValue: null,
- * })
- *
- * function ReaderComponent() {
- *   const { value } = use()
- *
- *   return <div>{value}</div>
- * }
- *
- * function WriterComponent() {
- *   const { setValue } = use()
- *
- *   return (
- *     <button type='button' onClick={() => setValue((p: number) => p + 1)}>
- *       Change
- *     </button>
- *   )
- * }
- *
- * function App() {
- *   const [value, setValue] = useState(0)
- *
- *   return (
- *     <Provider value={{ value, setValue }}>
- *       <ReaderComponent />
- *       <WriterComponent />
- *     </Provider>
- *   )
- * }
- * ```
- */
-declare function createSplittingContext<T extends Record<string, any>>(defaultValue: {
-    [K in keyof T]: Partial<T[K]> | null;
-} | (keyof T)[]): {
-    /**
-     * The provider component of the splitting context.
-     *
-     * @see https://faasjs.com/doc/react/functions/createSplittingContext.html#provider
-     *
-     * @example
-     * ```tsx
-     * function App() {
-     *   const [value, setValue] = useState(0)
-     *
-     *   return (
-     *     <Provider value={{ value, setValue }}>
-     *       <ReaderComponent />
-     *       <WriterComponent />
-     *     </Provider>
-     *   )
-     * }
-     * ```
-     */
-    Provider<NewT extends T = T>(props: {
-        value?: Partial<NewT>;
-        children: ReactNode;
-        /**
-         * Whether to use memoization for the children.
-         *
-         * @default false
-         *
-         * `true`: memoize the children without dependencies.
-         * `any[]`: memoize the children with specific dependencies.
-         */
-        memo?: true | any[];
-        /**
-         * An object containing initial values that will be automatically converted into state variables using {@link useSplittingState} hook. Each property will create both a state value and its setter following the pattern: value/setValue.
-         *
-         * @example
-         * ```tsx
-         * <Provider
-         *  initializeStates={{
-         *    value: 0,
-         *  }}
-         * >
-         *   // Children will have access to: value, setValue
-         * </Provider>
-         */
-        initializeStates?: Partial<NewT>;
-    }): ReactNode;
-    /**
-     * The hook to use the splitting context.
-     *
-     * @see https://faasjs.com/doc/react/functions/createSplittingContext.html#use
-     *
-     * @example
-     * ```tsx
-     * function ChildComponent() {
-     *   const { value, setValue } = use()
-     *
-     *   return <div>{value}<button onClick={() => setValue(1)}>change value</button></div>
-     * }
-     * ```
-     */
-    use: <NewT extends T = T>() => Readonly<NewT>;
-};
-
-type SetPrefix<S extends string | number | symbol> = S extends string ? S extends `${infer First}${infer Rest}` ? `set${Capitalize<First>}${Rest}` : never : never;
-type StateSetters<T> = {
-    [K in keyof T as SetPrefix<K>]: Dispatch<SetStateAction<T[K]>>;
-};
-type StatesWithSetters<T> = T & StateSetters<T>;
-/**
- * A hook that initializes and splits state variables and their corresponding setters.
- *
- * @template T - A generic type that extends a record with string keys and any values.
- * @param {T} initialStates - An object containing the initial states.
- *
- * @example
- * ```tsx
- * function Counter() {
- *   const { count, setCount, name, setName } = useSplittingState({ count: 0, name: 'John' });
- *
- *   return <>{name}: {count}</>
- * }
- * ```
- */
-declare function useSplittingState<T extends Record<string, unknown>>(initialStates: T): StatesWithSetters<T>;
-
-/**
- * Hook to store the previous value of a state or prop.
- *
- * @template T - The type of the value.
- * @param {T} value - The current value to be stored.
- * @returns {T | undefined} - The previous value, or undefined if there is no previous value.
- */
-declare function usePrevious<T = any>(value: T): T | undefined;
-
-/**
- * Custom hook that returns a stateful value and a ref to that value.
- *
- * @template T - The type of the value.
- * @param {T} initialValue - The initial value of the state.
- * @returns {[T, (value: T) => void, RefObject<T>]} - The stateful value, a function to set the value, and a ref to the value.
- *
- * @example
- * ```tsx
- * import { useStateRef } from '@faasjs/react'
- *
- * function MyComponent() {
- *  const [value, setValue, ref] = useStateRef(0)
- *
- * return (
- *   <div>
- *     <p>Value: {value}</p>
- *     <button onClick={() => setValue(value + 1)}>Increment</button>
- *     <button onClick={() => console.log(ref.current)}>Submit</button>
- *   </div>
- * )
- */
-declare function useStateRef<T = any>(initialValue?: T): [T, Dispatch<SetStateAction<T>>, RefObject<T>];
-
-/**
- * Injects FaasData props.
- */
-type FaasDataInjection<PathOrData extends FaasAction = any> = {
-    action: PathOrData | string;
-    params: Record<string, any>;
-    loading: boolean;
-    reloadTimes: number;
-    data: FaasData<PathOrData>;
-    error: any;
-    promise: Promise<Response<FaasData<PathOrData>>>;
-    /**
-     * Reloads data with new or existing parameters.
-     *
-     * **Note**: It will sets skip to false before loading data.
-     */
-    reload(params?: Record<string, any>): Promise<Response<PathOrData>>;
-    setData: React.Dispatch<React.SetStateAction<FaasData<PathOrData>>>;
-    setLoading: React.Dispatch<React.SetStateAction<boolean>>;
-    setPromise: React.Dispatch<React.SetStateAction<Promise<Response<FaasData<PathOrData>>>>>;
-    setError: React.Dispatch<React.SetStateAction<any>>;
-};
-type FaasDataWrapperProps<PathOrData extends FaasAction> = {
-    render?(args: FaasDataInjection<PathOrData>): JSX.Element | JSX.Element[];
-    children?: React.ReactElement<Partial<FaasDataInjection<PathOrData>>>;
-    fallback?: JSX.Element | false;
-    action: PathOrData | string;
-    params?: FaasParams<PathOrData>;
-    onDataChange?(args: FaasDataInjection<PathOrData>): void;
-    /** use custom data, should work with setData */
-    data?: FaasData<PathOrData>;
-    /** use custom setData, should work with data */
-    setData?: React.Dispatch<React.SetStateAction<FaasData<PathOrData>>>;
-    baseUrl?: BaseUrl;
-};
-declare function FaasDataWrapper<PathOrData extends FaasAction>(props: FaasDataWrapperProps<PathOrData>): JSX.Element;
-declare namespace FaasDataWrapper {
-    var displayName: string;
-    var whyDidYouRender: boolean;
-}
-/**
- * HOC to wrap a component with FaasDataWrapper
- *
- * @example
- * ```tsx
- * const MyComponent = withFaasData(({ data }) => <div>{data.name}</div>, { action: 'test', params: { a: 1 } })
- * ```
- */
-declare function withFaasData<PathOrData extends FaasAction, TComponentProps extends Required<FaasDataInjection<PathOrData>> = Required<FaasDataInjection<PathOrData>>>(Component: React.FC<TComponentProps & Record<string, any>>, faasProps: FaasDataWrapperProps<PathOrData>): React.FC<Omit<TComponentProps, keyof FaasDataInjection<PathOrData>> & Record<string, any>>;
-
-type useFaasOptions<PathOrData extends FaasAction> = {
-    params?: FaasParams<PathOrData>;
-    data?: FaasData<PathOrData>;
-    setData?: React.Dispatch<React.SetStateAction<FaasData<PathOrData>>>;
-    /**
-     * If skip is true, the request will not be sent.
-     *
-     * However, you can still use reload to send the request.
-     */
-    skip?: boolean | ((params: FaasParams<PathOrData>) => boolean);
-    /** Send the last request after milliseconds */
-    debounce?: number;
-    baseUrl?: BaseUrl;
-};
-/**
- * Request faas server with React hook
- *
- * @param action {string} action name
- * @param defaultParams {object} initial action params
- * @returns {FaasDataInjection<any>}
- *
- * @example
- * ```tsx
- * function Post ({ id }) {
- *   const { data } = useFaas<{ title: string }>('post/get', { id })
- *   return <h1>{data.title}</h1>
- * }
- * ```
- */
-declare function useFaas<PathOrData extends FaasAction>(action: PathOrData | string, defaultParams: FaasParams<PathOrData>, options?: useFaasOptions<PathOrData>): FaasDataInjection<PathOrData>;
-declare namespace useFaas {
-    var whyDidYouRender: boolean;
-}
-
-type OnError = (action: string, params: Record<string, any>) => (res: ResponseError) => Promise<void>;
-type FaasReactClientOptions = {
-    /** @default `/` */
-    baseUrl?: BaseUrl;
-    options?: Options;
-    /**
-     * @example
-     * ```ts
-     * onError: (action, params) => async (res) => {
-     *   console.error(action, params, res)
-     * }
-     * ```
-     */
-    onError?: OnError;
-};
-type FaasReactClientInstance = {
-    id: string;
-    faas: <PathOrData extends FaasAction>(action: PathOrData | string, params: FaasParams<PathOrData>, options?: Options) => Promise<Response<FaasData<PathOrData>>>;
-    useFaas: <PathOrData extends FaasAction>(action: PathOrData | string, defaultParams: FaasParams<PathOrData>, options?: useFaasOptions<PathOrData>) => FaasDataInjection<PathOrData>;
-    FaasDataWrapper<PathOrData extends FaasAction>(props: FaasDataWrapperProps<PathOrData>): JSX.Element;
-    onError: OnError;
-    browserClient: FaasBrowserClient;
-};
-/**
- * Before use faas, you should initialize a FaasReactClient.
- *
- * @param props.baseUrl {string} The baseUrl of your faas server
- * @param props.options {Options} The options of client
- * @returns {FaasReactClientInstance}
- *
- * @example
- * ```ts
- * const client = FaasReactClient({
- *   baseUrl: 'localhost:8080/api/'
- * })
- * ```
- */
-declare function FaasReactClient({ baseUrl, options, onError }?: FaasReactClientOptions): FaasReactClientInstance;
-/**
- * Get FaasReactClient instance
- *
- * @param host {string} empty string for default host
- * @returns {FaasReactClientInstance}
- *
- * @example
- * ```ts
- * getClient()
- * // or
- * getClient('another-host')
- * ```
- */
-declare function getClient(host?: string): FaasReactClientInstance;
-
-/**
- * Request faas server
- *
- * @param action {string} action name
- * @param params {object} action params
- * @returns {Promise<Response<any>>}
- *
- * @example
- * ```ts
- * faas<{ title: string }>('post/get', { id: 1 }).then(res => {
- *   console.log(res.data.title)
- * })
- * ```
- */
-declare function faas<PathOrData extends FaasAction>(action: PathOrData | string, params: FaasParams<PathOrData>, options?: Options): Promise<Response<FaasData<PathOrData>>>;
-
-interface ErrorBoundaryProps {
-    children?: ReactNode;
-    onError?: (error: Error | null, info: any) => void;
-    errorChildren?: ReactElement<ErrorChildrenProps>;
-}
-type ErrorChildrenProps = {
-    error?: Error;
-    info?: any;
-    errorMessage?: string;
-    errorDescription?: string;
-};
-declare class ErrorBoundary extends Component<ErrorBoundaryProps, {
-    error?: Error;
-    info?: {
-        componentStack?: string;
-    };
-}> {
-    static displayName: string;
-    static whyDidYouRender: boolean;
-    constructor(props: ErrorBoundaryProps);
-    componentDidCatch(error: Error | null, info: any): void;
-    render(): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | react.ReactPortal | ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<ReactNode>> | react_jsx_runtime.JSX.Element;
-}
-
-type OptionalWrapperProps<TWrapper extends ComponentType<{
-    children: ReactNode;
-}> = any> = {
-    condition: boolean;
-    Wrapper: TWrapper;
-    wrapperProps?: ComponentProps<TWrapper>;
-    children: ReactNode;
-};
-/**
- * A wrapper component that conditionally wraps its children with a provided wrapper component.
- *
- * @example
- * ```tsx
- * import { OptionalWrapper } from '@faasjs/react'
- *
- * const Wrapper = ({ children }: { children: React.ReactNode }) => (
- *   <div className='wrapper'>{children}</div>
- * )
- *
- * const App = () => (
- *   <OptionalWrapper condition={true} Wrapper={Wrapper}>
- *     <span>Test</span>
- *   </OptionalWrapper>
- * )
- * ```
- */
-declare const OptionalWrapper: React.FC<OptionalWrapperProps> & {
-    whyDidYouRender: boolean;
-};
-
-/**
- * Props for the FormButtonElement component.
- *
- * @property {React.ReactNode} [children] - The content to be displayed inside the button.
- * @property {boolean} disabled - Indicates whether the button is disabled.
- * @property {() => Promise<void>} submit - A function to be called when the button is clicked, which returns a promise.
- */
-type FormButtonElementProps = {
-    children?: React.ReactNode;
-    submitting: boolean;
-    submit: () => Promise<void>;
-};
-
-/**
- * Props for the Form Input Element component.
- *
- * @property {string} name - The name of the input element.
- * @property {any} value - The current value of the input element.
- * @property {(value: any) => void} onChange - Callback function to handle changes to the input value.
- */
-type FormInputElementProps = {
-    name: string;
-    value: any;
-    onChange: (value: any) => void;
-};
-
-/**
- * Props for the FormLabelElement component.
- *
- * @typedef {Object} FormLabelElementProps
- * @property {string} name - The name of the form element.
- * @property {ReactNode} [title] - Optional title for the form element.
- * @property {ReactNode} [description] - Optional description for the form element.
- * @property {Error} [error] - Optional error associated with the form element.
- * @property {ReactNode} children - The child elements, typically an input element.
- */
-type FormLabelElementProps = {
-    name: string;
-    title?: ReactNode;
-    description?: ReactNode;
-    error?: Error;
-    /** as Input element */
-    children: ReactNode;
-};
-
-/**
- * Represents the types of form elements used in the form.
- *
- * @typedef {Object} FormElementTypes
- * @property {ComponentType<FormLabelElementProps>} Label - The component type for the form label element.
- * @property {ComponentType<FormInputElementProps>} Input - The component type for the form input element.
- * @property {ComponentType<FormButtonElementProps>} Button - The component type for the form button element.
- */
-type FormElementTypes = {
-    Label: ComponentType<FormLabelElementProps>;
-    Input: ComponentType<FormInputElementProps>;
-    Button: ComponentType<FormButtonElementProps>;
-};
-declare const FormDefaultElements: FormElementTypes;
-
-declare const FormDefaultLang: {
-    submit: string;
-    required: string;
-    string: string;
-    number: string;
-};
-type FormLang = typeof FormDefaultLang;
-
-/**
- * A type representing a form validation rule.
- *
- * @template Options - The type of the options that can be passed to the rule.
- *
- * @param value - The value to be validated.
- * @param options - Optional. Additional options that can be used in the validation.
- * @param lang - Optional. The language settings that can be used in the validation.
- *
- * @returns A promise that resolves if the validation is successful, or rejects with an error if the validation fails.
- *
- * @example
- * ```ts
- * async function required(value: any, options: boolean, lang?: FormLang) {
- *   if (value === null || value === undefined || value === '' || Number.isNaN(value))
- *     throw Error(lang?.required)
- * }
- * ```
- */
-type FormRule<Options = any> = (value: any, options?: Options, lang?: FormLang) => Promise<void>;
-type InferRuleOption<T> = T extends (value: any, options: infer O, lang?: FormLang) => Promise<void> ? O : never;
-/**
- * A type representing a set of form validation rules.
- *
- * @typedef {Record<string, FormRule>} FormRules
- *
- * Each key in the record represents the name of a form field, and the corresponding value is a `FormRule` object that defines the validation rules for that field.
- */
-type FormRules = Record<string, FormRule>;
-type InferFormRulesOptions<T> = {
-    [K in keyof T]: InferRuleOption<T[K]>;
-};
-/**
- * Default validation rules for a form.
- *
- * @constant
- * @type {FormRules}
- */
-declare const FormDefaultRules: FormRules;
-type FormDefaultRulesOptions = InferFormRulesOptions<typeof FormDefaultRules>;
-declare function validValues(rules: FormRules, items: FormItemProps[], values: Record<string, any>, lang: FormLang): Promise<Record<string, Error>>;
-
-type InferFormInputProps<T extends ComponentType<FormInputElementProps> | JSXElementConstructor<any>> = T extends ComponentType<FormInputElementProps> ? Omit<ComponentProps<T>, 'name' | 'value' | 'onChange'> : Omit<ComponentProps<T>, 'name' | 'value'>;
-type FormInputProps<FormElements extends FormElementTypes = FormElementTypes> = {
-    Input?: ComponentType<FormInputElementProps>;
-    props?: InferFormInputProps<FormElements['Input']>;
-};
-
-type FormItemName = string;
-type FormItemProps<FormElements extends FormElementTypes = FormElementTypes, FormRulesOptions extends Record<string, any> = FormDefaultRulesOptions> = {
-    name: FormItemName;
-    label?: Omit<FormLabelElementProps, 'name' | 'children'> & {
-        Label?: ComponentType<FormLabelElementProps>;
-    };
-    input?: FormInputProps<FormElements>;
-    rules?: FormRulesOptions;
-};
-declare function FormItem(props: FormItemProps): react_jsx_runtime.JSX.Element;
-declare namespace FormItem {
-    var displayName: string;
-    var whyDidYouRender: boolean;
-}
-
-type FormProps<Values extends Record<string, any> = Record<string, any>, FormElements extends FormElementTypes = FormElementTypes, Rules extends FormRules = typeof FormDefaultRules> = {
-    items: FormItemProps<FormElements, InferFormRulesOptions<Rules>>[];
-    onSubmit?: (values: Values) => Promise<void>;
-    Elements?: Partial<FormElements>;
-    lang?: Partial<FormLang>;
-    defaultValues?: Values;
-    rules?: typeof FormDefaultRules & Rules;
-};
-/**
- * FormContainer component is a wrapper that provides context and state management for form elements.
- * It initializes form states such as values, errors, submitting status, elements, language, and rules.
- *
- * @template Values - The type of form values, defaults to Record<string, any>.
- * @template FormElements - The type of form elements, defaults to FormElementTypes.
- * @template Rules - The type of form rules, defaults to FormDefaultRules.
- *
- * @param {FormProps<Values, FormElements, Rules>} props - The properties for the FormContainer component.
- * @param {Values} props.defaultValues - The default values for the form fields.
- * @param {FormElements} props.Elements - The form elements to be used in the form.
- * @param {Rules} props.rules - The validation rules for the form fields.
- * @param {FormLang} props.lang - The language settings for the form.
- * @param {Partial<FormContextProps>} props - Additional properties for the form context.
- *
- * @returns {JSX.Element} The FormContainer component.
- *
- * @example
- * ```tsx
- * import { Form } from '@faasjs/react'
- *
- * function MyForm() {
- *   return <Form
- *     items={[
- *       { name: 'name' },
- *     ]}
- *   />
- * }
- * ```
- */
-declare function FormContainer<Values extends Record<string, any> = Record<string, any>, FormElements extends FormElementTypes = FormElementTypes, Rules extends FormRules = typeof FormDefaultRules>({ defaultValues, Elements, rules, lang, items, ...props }: FormProps<Values, FormElements, Rules>): react_jsx_runtime.JSX.Element;
-declare namespace FormContainer {
-    var displayName: string;
-    var whyDidYouRender: boolean;
-}
-
-type FormContextProps<Values extends Record<string, any> = Record<string, any>, FormElements extends FormElementTypes = FormElementTypes, Rules extends FormRules = typeof FormDefaultRules> = {
-    items: FormItemProps<FormElements, InferFormRulesOptions<Rules>>[];
-    onSubmit: (values: Values) => Promise<void>;
-    Elements: FormElementTypes;
-    lang: FormLang;
-    rules: typeof FormDefaultRules & Rules;
-    submitting: boolean;
-    setSubmitting: Dispatch<SetStateAction<boolean>>;
-    values: Values;
-    setValues: Dispatch<SetStateAction<Values>>;
-    errors: Record<string, Error>;
-    setErrors: Dispatch<SetStateAction<Record<string, Error>>>;
-    valuesRef: RefObject<Values>;
-};
-declare const FormContextProvider: <NewT extends FormContextProps<Record<string, any>, FormElementTypes, FormRules> = FormContextProps<Record<string, any>, FormElementTypes, FormRules>>(props: {
-    value?: Partial<NewT>;
-    children: react.ReactNode;
-    memo?: true | any[];
-    initializeStates?: Partial<NewT>;
-}) => react.ReactNode;
-declare const useFormContext: <NewT extends FormContextProps<Record<string, any>, FormElementTypes, FormRules> = FormContextProps<Record<string, any>, FormElementTypes, FormRules>>() => Readonly<NewT>;
-
-export { ErrorBoundary, type ErrorBoundaryProps, type ErrorChildrenProps, type FaasDataInjection, FaasDataWrapper, type FaasDataWrapperProps, FaasReactClient, type FaasReactClientInstance, type FaasReactClientOptions, FormContainer as Form, type FormButtonElementProps, type FormContextProps, FormContextProvider, FormDefaultElements, FormDefaultLang, FormDefaultRules, type FormDefaultRulesOptions, type FormElementTypes, type FormInputElementProps, FormItem, type FormItemName, type FormItemProps, type FormLabelElementProps, type FormLang, type FormProps, type FormRule, type FormRules, type InferFormRulesOptions, type OnError, OptionalWrapper, type OptionalWrapperProps, createSplittingContext, equal, faas, getClient, useConstant, useEqualCallback, useEqualEffect, useEqualMemo, useEqualMemoize, useFaas, type useFaasOptions, useFormContext, usePrevious, useSplittingState, useStateRef, validValues, withFaasData };