@bleedingdev/modern-js-runtime 3.2.0-ultramodern.0

package/dist/esm-node/router/runtime/rsc-router.mjs

@@ -0,0 +1,322 @@
+import "node:module";
+import { Fragment, jsx } from "react/jsx-runtime";
+import { ElementsContext, createFromReadableStream } from "@modern-js/render/client";
+import { StaticRouterProvider, createBrowserRouter, createStaticRouter, redirect } from "@modern-js/runtime-utils/router";
+import react from "react";
+import { CSSLinks } from "./CSSLinks.mjs";
+const safeUse = (value)=>{
+    const reactUse = react.use;
+    if ('function' == typeof reactUse) return reactUse(value);
+    return null;
+};
+function collectCssFilesFromRoutes(matches, routes) {
+    const cssFiles = [];
+    for (const match of matches){
+        const route = findRouteInTree(routes, match.route.id);
+        if (!route) continue;
+        const component = route.Component;
+        if (component && 'function' == typeof component && 'entryCssFiles' in component) {
+            const css = component.entryCssFiles;
+            if (Array.isArray(css)) cssFiles.push(...css);
+        }
+    }
+    return Array.from(new Set(cssFiles));
+}
+const createServerPayload = (routerContext, routes)=>{
+    const cssFiles = collectCssFilesFromRoutes(routerContext.matches, routes);
+    let cssInjectionIndex = -1;
+    if (cssFiles.length > 0) {
+        for(let i = routerContext.matches.length - 1; i >= 0; i--){
+            const matchRoute = findRouteInTree(routes, routerContext.matches[i].route.id);
+            if (matchRoute && !matchRoute.isClientComponent) {
+                cssInjectionIndex = i;
+                break;
+            }
+        }
+        if (-1 === cssInjectionIndex) cssInjectionIndex = routerContext.matches.length - 1;
+    }
+    return {
+        type: 'render',
+        actionData: routerContext.actionData,
+        errors: routerContext.errors,
+        loaderData: routerContext.loaderData,
+        location: routerContext.location,
+        routes: routerContext.matches.map((match, index, matches)=>{
+            const route = match.route;
+            const element = route.element;
+            const parentMatch = index > 0 ? matches[index - 1] : void 0;
+            let processedElement;
+            if (element) {
+                const ElementComponent = element.type;
+                const elementProps = {
+                    loaderData: routerContext?.loaderData?.[route.id],
+                    actionData: routerContext?.actionData?.[route.id],
+                    params: match.params,
+                    matches: routerContext.matches.map((m)=>({
+                            id: m.route.id,
+                            pathname: m.pathname,
+                            params: m.params,
+                            data: routerContext?.loaderData?.[m.route.id],
+                            handle: m.route.handle
+                        }))
+                };
+                const routeElement = /*#__PURE__*/ react.createElement(ElementComponent, elementProps);
+                processedElement = index === cssInjectionIndex ? /*#__PURE__*/ react.createElement(react.Fragment, null, /*#__PURE__*/ react.createElement(CSSLinks, {
+                    cssFiles
+                }), routeElement) : routeElement;
+            }
+            return {
+                element: processedElement,
+                errorElement: route.errorElement,
+                handle: route.handle,
+                hasAction: !!route.action,
+                hasErrorBoundary: !!route.hasErrorBoundary,
+                hasLoader: !!route.loader,
+                hasClientLoader: !!route.hasClientLoader,
+                id: route.id,
+                index: route.index,
+                params: match.params,
+                parentId: parentMatch?.route.id || route.parentId,
+                path: route.path,
+                pathname: match.pathname,
+                pathnameBase: match.pathnameBase
+            };
+        })
+    };
+};
+const handleRSCRedirect = (headers, basename, status)=>{
+    const newHeaders = new Headers(headers);
+    let redirectUrl = headers.get('Location');
+    if ('/' !== basename) redirectUrl = redirectUrl.replace(basename, '');
+    newHeaders.set('X-Modernjs-Redirect', redirectUrl);
+    newHeaders.set('X-Modernjs-BaseUrl', basename);
+    newHeaders.delete('Location');
+    return new Response(null, {
+        status: status,
+        headers: newHeaders
+    });
+};
+const prepareRSCRoutes = async (routes)=>{
+    const isLazyComponent = (component)=>null != component && 'object' == typeof component && '_init' in component && '_payload' in component;
+    const processRoutes = async (routesList)=>{
+        await Promise.all(routesList.map(async (route)=>{
+            const modernRoute = route;
+            if ('lazyImport' in modernRoute && isLazyComponent(modernRoute.component)) modernRoute.component = (await modernRoute.lazyImport()).default;
+            if (route.children && Array.isArray(route.children)) await processRoutes(route.children);
+        }));
+    };
+    await processRoutes(routes);
+};
+const mergeRoutes = (routes, originalRoutes)=>{
+    if (!originalRoutes || !Array.isArray(originalRoutes)) return routes;
+    const routesMap = new Map();
+    const buildRoutesMap = (routesList)=>{
+        routesList.forEach((route)=>{
+            if (route.id) routesMap.set(route.id, route);
+            if ('children' in route && route.children && Array.isArray(route.children)) buildRoutesMap(route.children);
+        });
+    };
+    buildRoutesMap(routes);
+    const mergeRoutesRecursive = (origRoutes)=>origRoutes.map((origRoute)=>{
+            const modernOrig = origRoute;
+            if (modernOrig.id && routesMap.has(modernOrig.id)) {
+                const matchedRoute = routesMap.get(modernOrig.id);
+                const result = {
+                    loader: modernOrig.hasClientLoader ? modernOrig.loader : void 0,
+                    ...matchedRoute
+                };
+                if (modernOrig.isClientComponent) result.isClientComponent = true;
+                if (origRoute.children && Array.isArray(origRoute.children)) result.children = mergeRoutesRecursive(origRoute.children);
+                return result;
+            }
+            return origRoute;
+        });
+    return mergeRoutesRecursive(originalRoutes);
+};
+const findRouteInTree = (routes, routeId)=>{
+    for (const route of routes){
+        if (route.id === routeId) return route;
+        if (route.children && Array.isArray(route.children)) {
+            const found = findRouteInTree(route.children, routeId);
+            if (found) return found;
+        }
+    }
+    return null;
+};
+function getChangedMatches(matches, currentMatches) {
+    const currentById = new Map();
+    for (const m of currentMatches)if (m.route?.id) currentById.set(m.route.id, m);
+    return matches.filter((match)=>{
+        const current = currentById.get(match.route?.id);
+        return !current || JSON.stringify(current.params) !== JSON.stringify(match.params);
+    });
+}
+function canSkipRscFetch(matches, routerState) {
+    const changedMatches = getChangedMatches(matches, routerState?.matches || []);
+    return changedMatches.length > 0 && changedMatches.every((m)=>{
+        const route = m.route;
+        return route.isClientComponent && !(route.hasLoader && !route.hasClientLoader);
+    });
+}
+function injectRouteCss(routeId) {
+    if ("u" < typeof window) return;
+    const cssAssets = window._MODERNJS_ROUTE_MANIFEST?.routeAssets?.[routeId]?.referenceCssAssets;
+    if (!cssAssets) return;
+    const publicPath = window.__webpack_public_path__ || '/';
+    for (const css of cssAssets){
+        const href = css.startsWith('http') || css.startsWith('/') ? css : publicPath + css;
+        if (!document.querySelector(`link[href="${CSS.escape(href)}"]`)) {
+            const link = document.createElement('link');
+            link.rel = 'stylesheet';
+            link.href = href;
+            document.head.appendChild(link);
+        }
+    }
+}
+function ensureClientComponent(route, originalRoutes) {
+    if (route.isClientComponent && !route.Component) {
+        const origRoute = findRouteInTree(originalRoutes, route.id);
+        if (origRoute?.Component) {
+            route.Component = origRoute.Component;
+            delete route.element;
+        }
+    }
+}
+function resolveClientLoaders(matches, originalRoutes) {
+    const clientMatches = matches.filter((m)=>m.route.hasClientLoader);
+    if (0 === clientMatches.length) return Promise.resolve([]);
+    return Promise.all(clientMatches.map(async (clientMatch)=>{
+        const origRoute = findRouteInTree(originalRoutes, clientMatch.route.id);
+        clientMatch.route.loader = origRoute?.loader;
+        const result = await clientMatch.resolve();
+        return {
+            routeId: clientMatch.route.id,
+            result
+        };
+    }));
+}
+function applyLoaderResults(results, loaderResults) {
+    for (const { routeId, result } of loaderResults)results[routeId] = result;
+}
+async function resolveClientOnlyNavigation(matches, results, originalRoutes, routerState) {
+    const changedMatches = getChangedMatches(matches, routerState?.matches || []);
+    for (const match of changedMatches)ensureClientComponent(match.route, originalRoutes);
+    applyLoaderResults(results, await resolveClientLoaders(changedMatches, originalRoutes));
+    for (const match of changedMatches)if (match.route.id) injectRouteCss(match.route.id);
+    return results;
+}
+const createClientRouterFromPayload = (payload, originalRoutes, basename = '')=>{
+    const processedRoutes = payload.routes.reduceRight((previous, route)=>{
+        if (previous.length > 0) return [
+            {
+                ...route,
+                children: previous
+            }
+        ];
+        return [
+            route
+        ];
+    }, []);
+    const mergedRoutes = mergeRoutes(processedRoutes, originalRoutes);
+    const router = createBrowserRouter(mergedRoutes, {
+        hydrationData: payload,
+        basename: basename,
+        dataStrategy: async ({ request, matches })=>{
+            const results = {};
+            if (canSkipRscFetch(matches, router.state)) return resolveClientOnlyNavigation(matches, results, originalRoutes, router.state);
+            const fetchPromise = fetch(request.url, {
+                headers: {
+                    'x-rsc-tree': 'true'
+                }
+            });
+            const clientLoadersPromise = resolveClientLoaders(matches, originalRoutes);
+            const res = await fetchPromise;
+            const redirectLocation = res.headers.get('X-Modernjs-Redirect');
+            if (redirectLocation) {
+                matches.forEach((match)=>{
+                    const routeId = match.route.id;
+                    if (routeId) results[routeId] = {
+                        type: 'data',
+                        result: redirect(redirectLocation)
+                    };
+                });
+                return results;
+            }
+            applyLoaderResults(results, await clientLoadersPromise);
+            if (!res.body) throw new Error('Response body is null');
+            const payload = await createFromReadableStream(res.body);
+            if ('object' != typeof payload || null === payload || void 0 === payload.type || 'render' !== payload.type) throw new Error('Unexpected payload type');
+            const serverPayload = payload;
+            matches.forEach((match)=>{
+                const routeId = match.route.id;
+                const matchedRoute = serverPayload.routes.find((route)=>route.id === routeId);
+                if (matchedRoute) {
+                    const modernMatch = match.route;
+                    router.patchRoutes(matchedRoute.parentId ?? null, [
+                        matchedRoute
+                    ], true);
+                    if (modernMatch.isClientComponent && modernMatch.Component) delete modernMatch.Component;
+                }
+                if (serverPayload.loaderData && routeId in serverPayload.loaderData) results[routeId] = {
+                    type: 'data',
+                    result: serverPayload.loaderData[routeId]
+                };
+            });
+            return results;
+        }
+    });
+    return router;
+};
+const createRSCStaticRouterComponent = (payload, basename)=>{
+    const routerContext = {
+        actionData: payload.actionData,
+        actionHeaders: {},
+        activeDeferreds: {},
+        basename: basename || '',
+        errors: payload.errors,
+        loaderData: payload.loaderData,
+        loaderHeaders: {},
+        location: payload.location,
+        statusCode: 200,
+        matches: payload.routes.map((match)=>({
+                params: match.params,
+                pathname: match.pathname,
+                pathnameBase: match.pathnameBase,
+                route: {
+                    id: match.id,
+                    action: match.hasAction || !!match.clientAction,
+                    handle: match.handle,
+                    hasErrorBoundary: match.hasErrorBoundary,
+                    loader: match.hasLoader || !!match.clientLoader,
+                    index: match.index,
+                    path: match.path,
+                    shouldRevalidate: match.shouldRevalidate
+                }
+            }))
+    };
+    const processedRoutes = payload.routes.reduceRight((previous, route)=>{
+        if (previous.length > 0) return [
+            {
+                ...route,
+                children: previous
+            }
+        ];
+        return [
+            route
+        ];
+    }, []);
+    const router = createStaticRouter(processedRoutes, routerContext);
+    return /*#__PURE__*/ jsx(StaticRouterProvider, {
+        context: routerContext,
+        router: router,
+        hydrate: false
+    });
+};
+const RSCStaticRouter = ({ basename })=>{
+    const payload = safeUse(safeUse(ElementsContext));
+    if (!payload || 'render' !== payload.type) return null;
+    return /*#__PURE__*/ jsx(Fragment, {
+        children: createRSCStaticRouterComponent(payload, basename)
+    });
+};
+export { RSCStaticRouter, createClientRouterFromPayload, createServerPayload, handleRSCRedirect, prepareRSCRoutes };

package/dist/esm-node/router/runtime/rsc.mjs

@@ -0,0 +1,2 @@
+import "node:module";
+export * from "@modern-js/runtime-utils/router/rsc";

package/dist/esm-node/router/runtime/server.mjs

@@ -0,0 +1,2 @@
+import "node:module";
+export * from "@modern-js/runtime-utils/router";

package/dist/esm-node/router/runtime/tanstack/basepathRewrite.mjs

@@ -0,0 +1,29 @@
+import "node:module";
+function normalizeBasepath(basepath) {
+    if (!basepath) return '/';
+    let normalized = basepath.startsWith('/') ? basepath : `/${basepath}`;
+    if (normalized.length > 1 && normalized.endsWith('/')) normalized = normalized.slice(0, -1);
+    return normalized || '/';
+}
+function createModernBasepathRewrite(basepath, caseSensitive = false) {
+    const normalizedBasepath = normalizeBasepath(basepath);
+    if ('/' === normalizedBasepath) return;
+    const normalizedBasepathWithSlash = `${normalizedBasepath}/`;
+    const checkBasepath = caseSensitive ? normalizedBasepath : normalizedBasepath.toLowerCase();
+    const checkBasepathWithSlash = caseSensitive ? normalizedBasepathWithSlash : normalizedBasepathWithSlash.toLowerCase();
+    return {
+        input: ({ url })=>{
+            const pathname = caseSensitive ? url.pathname : url.pathname.toLowerCase();
+            if (pathname === checkBasepath) url.pathname = '/';
+            else if (pathname.startsWith(checkBasepathWithSlash)) url.pathname = url.pathname.slice(normalizedBasepath.length) || '/';
+            return url;
+        },
+        output: ({ url })=>{
+            const pathname = url.pathname || '/';
+            if ('/' === pathname) url.pathname = normalizedBasepath;
+            else url.pathname = `${normalizedBasepath}${pathname.startsWith('/') ? '' : '/'}${pathname}`;
+            return url;
+        }
+    };
+}
+export { createModernBasepathRewrite };

package/dist/esm-node/router/runtime/tanstack/dataMutation.mjs

@@ -0,0 +1,306 @@
+import "node:module";
+import { jsx } from "react/jsx-runtime";
+import { useRouter } from "@tanstack/react-router";
+import { useCallback, useRef, useState } from "react";
+class RouteActionResponseError extends Error {
+    constructor(response, data){
+        super(`Route action failed with status ${response.status}`);
+        this.name = 'RouteActionResponseError';
+        this.response = response;
+        this.data = data;
+    }
+}
+function formDataToUrlSearchParams(formData) {
+    const searchParams = new URLSearchParams();
+    formData.forEach((value, key)=>{
+        if ('string' == typeof value) searchParams.append(key, value);
+    });
+    return searchParams;
+}
+function formDataToTextPlain(formData) {
+    return Array.from(formData.entries()).map(([key, value])=>`${key}=${String(value)}`).join('\n');
+}
+function toFormData(target) {
+    if (target instanceof HTMLFormElement) return new FormData(target);
+    if (target instanceof FormData) return target;
+    if (target instanceof URLSearchParams) {
+        const formData = new FormData();
+        target.forEach((value, key)=>{
+            formData.append(key, value);
+        });
+        return formData;
+    }
+    const formData = new FormData();
+    Object.entries(target).forEach(([key, value])=>{
+        if (null == value) return;
+        formData.append(key, String(value));
+    });
+    return formData;
+}
+function getSubmitter(event) {
+    const nativeEvent = event.nativeEvent;
+    const submitter = nativeEvent?.submitter;
+    if (submitter instanceof HTMLButtonElement || submitter instanceof HTMLInputElement) return submitter;
+    return null;
+}
+function createFormDataFromSubmit({ form, submitter }) {
+    if (submitter) try {
+        return new FormData(form, submitter);
+    } catch  {}
+    return new FormData(form);
+}
+function resolveSubmitOptionsFromForm({ form, submitter, action, method, encType }) {
+    const resolvedAction = submitter?.getAttribute('formaction') || action || form.getAttribute('action') || '.';
+    const resolvedMethod = (submitter?.getAttribute('formmethod') || method || form.getAttribute('method') || 'get').toLowerCase();
+    const resolvedEncType = submitter?.getAttribute('formenctype') || encType || form.getAttribute('enctype') || 'application/x-www-form-urlencoded';
+    return {
+        action: resolvedAction,
+        method: resolvedMethod,
+        encType: resolvedEncType
+    };
+}
+function resolveRouteHandlers(router, actionTo) {
+    const builtLocation = router.buildLocation({
+        to: actionTo
+    });
+    const href = router.getParsedLocationHref(builtLocation);
+    const matchedRoutes = router.getMatchedRoutes(builtLocation.pathname);
+    const routeStaticData = matchedRoutes.foundRoute?.options?.staticData;
+    const action = routeStaticData?.modernRouteAction;
+    const loader = routeStaticData?.modernRouteLoader;
+    return {
+        action,
+        loader,
+        href,
+        params: matchedRoutes.routeParams || {}
+    };
+}
+function isRedirectResponse(value) {
+    if (!(value instanceof Response)) return false;
+    return [
+        301,
+        302,
+        303,
+        307,
+        308
+    ].includes(value.status);
+}
+async function parseResponseData(response) {
+    if (204 === response.status) return null;
+    const contentType = response.headers.get('Content-Type') || '';
+    if (contentType.includes('application/json')) return response.json();
+    return response.text();
+}
+async function parseResponseResultOrThrow(response) {
+    const parsed = await parseResponseData(response);
+    if (!response.ok) throw new RouteActionResponseError(response, parsed);
+    return parsed;
+}
+async function submitRouteAction({ router, target, options = {}, isFetcher = false, onInvalidateStart }) {
+    const method = (options.method || 'post').toLowerCase();
+    const encType = options.encType || 'application/x-www-form-urlencoded';
+    const actionTo = options.action || '.';
+    const formData = toFormData(target);
+    const resolved = resolveRouteHandlers(router, actionTo);
+    if ('get' === method) {
+        const search = formDataToUrlSearchParams(formData).toString();
+        const requestUrl = new URL(resolved.href, window.location.origin);
+        requestUrl.search = search;
+        if (isFetcher && resolved.loader) {
+            const result = await resolved.loader({
+                request: new Request(requestUrl, {
+                    method: 'GET'
+                }),
+                params: resolved.params
+            });
+            if (result instanceof Response) {
+                const redirectTo = result.headers.get('X-Modernjs-Redirect') || result.headers.get('Location');
+                if (redirectTo || isRedirectResponse(result)) {
+                    await router.navigate({
+                        to: redirectTo || '/'
+                    });
+                    return parseResponseData(result);
+                }
+                return parseResponseResultOrThrow(result);
+            }
+            return result;
+        }
+        await router.navigate({
+            href: search ? `${resolved.href}?${search}` : resolved.href
+        });
+        return;
+    }
+    if (!resolved.action) throw new Error(`No route action found for "${actionTo}"`);
+    const headers = new Headers();
+    let body = null;
+    if (encType.includes('application/json')) {
+        headers.set('Content-Type', 'application/json');
+        body = JSON.stringify(Object.fromEntries(formDataToUrlSearchParams(formData).entries()));
+    } else if (encType.includes('text/plain')) {
+        headers.set('Content-Type', 'text/plain;charset=UTF-8');
+        body = formDataToTextPlain(formData);
+    } else if (encType.includes('application/x-www-form-urlencoded')) {
+        headers.set('Content-Type', 'application/x-www-form-urlencoded;charset=UTF-8');
+        body = formDataToUrlSearchParams(formData);
+    } else body = formData;
+    const request = new Request(new URL(resolved.href, window.location.origin), {
+        method: method.toUpperCase(),
+        headers,
+        body
+    });
+    const result = await resolved.action({
+        request,
+        params: resolved.params
+    });
+    if (result instanceof Response) {
+        const redirectTo = result.headers.get('X-Modernjs-Redirect') || result.headers.get('Location');
+        if (redirectTo || isRedirectResponse(result)) {
+            await router.navigate({
+                to: redirectTo || '/'
+            });
+            return parseResponseData(result);
+        }
+        const parsed = isFetcher ? await parseResponseResultOrThrow(result) : await parseResponseData(result);
+        onInvalidateStart?.();
+        await router.invalidate();
+        return parsed;
+    }
+    onInvalidateStart?.();
+    await router.invalidate();
+    return result;
+}
+function Form({ action, method = 'get', encType, reloadDocument, onSubmit, ...rest }) {
+    const router = useRouter();
+    const handleSubmit = useCallback(async (event)=>{
+        onSubmit?.(event);
+        if (event.defaultPrevented || reloadDocument) return;
+        event.preventDefault();
+        const submitter = getSubmitter(event);
+        const formData = createFormDataFromSubmit({
+            form: event.currentTarget,
+            submitter
+        });
+        const normalizedOptions = resolveSubmitOptionsFromForm({
+            form: event.currentTarget,
+            submitter,
+            action,
+            method,
+            encType
+        });
+        await submitRouteAction({
+            router,
+            target: formData,
+            options: normalizedOptions
+        });
+    }, [
+        action,
+        encType,
+        method,
+        onSubmit,
+        reloadDocument,
+        router
+    ]);
+    return /*#__PURE__*/ jsx("form", {
+        ...rest,
+        action: action,
+        method: method,
+        encType: encType,
+        onSubmit: handleSubmit
+    });
+}
+function useFetcher() {
+    const router = useRouter();
+    const [state, setState] = useState('idle');
+    const [data, setData] = useState(void 0);
+    const [error, setError] = useState(void 0);
+    const requestStatesRef = useRef(new Map());
+    const requestIdRef = useRef(0);
+    const syncStateFromRequests = useCallback(()=>{
+        let hasSubmitting = false;
+        let hasLoading = false;
+        requestStatesRef.current.forEach((requestState)=>{
+            if ('submitting' === requestState) hasSubmitting = true;
+            else if ('loading' === requestState) hasLoading = true;
+        });
+        if (hasSubmitting) return void setState('submitting');
+        if (hasLoading) return void setState('loading');
+        setState('idle');
+    }, []);
+    const setRequestState = useCallback((requestId, requestState)=>{
+        requestStatesRef.current.set(requestId, requestState);
+        syncStateFromRequests();
+    }, [
+        syncStateFromRequests
+    ]);
+    const clearRequestState = useCallback((requestId)=>{
+        requestStatesRef.current.delete(requestId);
+        syncStateFromRequests();
+    }, [
+        syncStateFromRequests
+    ]);
+    const submit = useCallback(async (target, options)=>{
+        setError(void 0);
+        const requestId = ++requestIdRef.current;
+        const normalizedMethod = (options?.method || 'post').toLowerCase();
+        const isLoaderSubmit = 'get' === normalizedMethod;
+        setRequestState(requestId, isLoaderSubmit ? 'loading' : 'submitting');
+        try {
+            const result = await submitRouteAction({
+                router,
+                target,
+                options,
+                isFetcher: true,
+                onInvalidateStart: ()=>{
+                    if (!isLoaderSubmit) setRequestState(requestId, 'loading');
+                }
+            });
+            setData(result);
+        } catch (err) {
+            setError(err);
+            throw err;
+        } finally{
+            clearRequestState(requestId);
+        }
+    }, [
+        clearRequestState,
+        router,
+        setRequestState
+    ]);
+    const FetcherForm = useCallback(({ action, method = 'get', encType, reloadDocument, onSubmit, ...rest })=>{
+        const handleSubmit = async (event)=>{
+            onSubmit?.(event);
+            if (event.defaultPrevented || reloadDocument) return;
+            event.preventDefault();
+            const submitter = getSubmitter(event);
+            const formData = createFormDataFromSubmit({
+                form: event.currentTarget,
+                submitter
+            });
+            const normalizedOptions = resolveSubmitOptionsFromForm({
+                form: event.currentTarget,
+                submitter,
+                action,
+                method,
+                encType
+            });
+            await submit(formData, normalizedOptions);
+        };
+        return /*#__PURE__*/ jsx("form", {
+            ...rest,
+            action: action,
+            method: method,
+            encType: encType,
+            onSubmit: handleSubmit
+        });
+    }, [
+        submit
+    ]);
+    return {
+        state,
+        data,
+        error,
+        Form: FetcherForm,
+        submit
+    };
+}
+export { Form, RouteActionResponseError, useFetcher };