@bleedingdev/modern-js-plugin-tanstack 3.5.0-ultramodern.9 → 3.5.0-ultramodern.90

package/dist/cjs/runtime/{pluginCore.js → clientBasepath.js}

@@ -27,28 +27,21 @@ var __webpack_require__ = {};
 })();
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-    getFinalRouteConfig: ()=>getFinalRouteConfig,
-    getMergedRouterConfig: ()=>getMergedRouterConfig
-});
-const context_namespaceObject = require("@modern-js/runtime/context");
-const merge_namespaceObject = require("@modern-js/runtime-utils/merge");
-function getMergedRouterConfig(api, userConfig) {
-    const pluginConfig = api.getRuntimeConfig();
-    return (0, merge_namespaceObject.merge)(pluginConfig.router || {}, userConfig);
+function normalizeBase(b) {
+    if (b.length > 1 && b.endsWith('/')) return b.slice(0, -1);
+    return b || '/';
 }
-function getFinalRouteConfig(mergedConfig) {
-    return {
-        routes: (0, context_namespaceObject.getGlobalRoutes)(),
-        globalApp: (0, context_namespaceObject.getGlobalLayoutApp)(),
-        ...mergedConfig.routesConfig
-    };
+function isSegmentPrefix(pathname, base) {
+    const b = normalizeBase(base);
+    const p = pathname || '/';
+    return p === b || p.startsWith(`${b}/`);
 }
-exports.getFinalRouteConfig = __webpack_exports__.getFinalRouteConfig;
-exports.getMergedRouterConfig = __webpack_exports__.getMergedRouterConfig;
+__webpack_require__.d(__webpack_exports__, {
+    isSegmentPrefix: ()=>isSegmentPrefix
+});
+exports.isSegmentPrefix = __webpack_exports__.isSegmentPrefix;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "getFinalRouteConfig",
-    "getMergedRouterConfig"
+    "isSegmentPrefix"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/runtime/clientHydration.js

@@ -0,0 +1,118 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    ModernRouterClient: ()=>ModernRouterClient,
+    getTanstackSsrHydrationPromise: ()=>getTanstackSsrHydrationPromise,
+    hasTanstackSsrHydrationRecord: ()=>hasTanstackSsrHydrationRecord,
+    hydrateTanstackRouter: ()=>hydrateTanstackRouter
+});
+const react_router_namespaceObject = require("@tanstack/react-router");
+const external_react_namespaceObject = require("react");
+const external_outlet_js_namespaceObject = require("./outlet.js");
+const external_routeTree_js_namespaceObject = require("./routeTree.js");
+const routerHydrationRecords = new WeakMap();
+const routeModulesKey = '_routeModules';
+function getCachedRouteModule(routeId) {
+    if ("u" < typeof window) return;
+    return window[routeModulesKey]?.[routeId];
+}
+function preloadHydratedRouteComponents(router) {
+    const preloadableRouter = router;
+    const routesById = preloadableRouter.routesById || {};
+    const matches = preloadableRouter.stores.matches.get();
+    return Promise.all(matches.map((match)=>{
+        if (void 0 === match.routeId || '' === match.routeId) return;
+        const route = routesById[match.routeId];
+        const component = route?.options?.component;
+        const preload = component?.load || component?.preload;
+        if ('function' != typeof preload) return;
+        return Promise.resolve(preload.call(component)).then((routeModule)=>{
+            const modernRouteId = route?.options?.staticData?.modernRouteId;
+            const cachedRouteModule = 'string' == typeof modernRouteId && '' !== modernRouteId ? getCachedRouteModule(modernRouteId) : void 0;
+            const resolvedComponent = (0, external_routeTree_js_namespaceObject.pickRouteModuleComponent)(cachedRouteModule ?? routeModule);
+            if (void 0 !== resolvedComponent && 'string' == typeof modernRouteId && '' !== modernRouteId) route.options.component = (0, external_outlet_js_namespaceObject.withModernRouteMatchContext)(resolvedComponent, modernRouteId);
+        });
+    })).then(()=>void 0);
+}
+function hydrateTanstackRouter(router) {
+    return import("@tanstack/react-router/ssr/client").then(({ hydrate })=>hydrate(router));
+}
+function getTanstackSsrHydrationRecord(router) {
+    const existingHydrationRecord = routerHydrationRecords.get(router);
+    if (void 0 !== existingHydrationRecord) return existingHydrationRecord;
+    const hydrationRecord = {
+        promise: Promise.resolve(),
+        status: 'pending'
+    };
+    routerHydrationRecords.set(router, hydrationRecord);
+    try {
+        hydrationRecord.promise = hydrateTanstackRouter(router).then((value)=>preloadHydratedRouteComponents(router).then(()=>value)).then((value)=>{
+            hydrationRecord.status = 'fulfilled';
+            return value;
+        }, (error)=>{
+            hydrationRecord.status = 'rejected';
+            hydrationRecord.error = error;
+            throw error;
+        });
+    } catch (error) {
+        hydrationRecord.status = 'rejected';
+        hydrationRecord.error = error;
+        hydrationRecord.promise = Promise.reject(error);
+        hydrationRecord.promise.catch(()=>{});
+    }
+    return hydrationRecord;
+}
+function getTanstackSsrHydrationPromise(router) {
+    return getTanstackSsrHydrationRecord(router).promise;
+}
+function hasTanstackSsrHydrationRecord(router) {
+    return routerHydrationRecords.has(router);
+}
+function ModernRouterClient({ router }) {
+    const hydrationRecord = getTanstackSsrHydrationRecord(router);
+    if ('pending' === hydrationRecord.status) throw hydrationRecord.promise;
+    if ('rejected' === hydrationRecord.status) throw hydrationRecord.error;
+    return (0, external_react_namespaceObject.createElement)(react_router_namespaceObject.RouterProvider, {
+        router
+    });
+}
+exports.ModernRouterClient = __webpack_exports__.ModernRouterClient;
+exports.getTanstackSsrHydrationPromise = __webpack_exports__.getTanstackSsrHydrationPromise;
+exports.hasTanstackSsrHydrationRecord = __webpack_exports__.hasTanstackSsrHydrationRecord;
+exports.hydrateTanstackRouter = __webpack_exports__.hydrateTanstackRouter;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ModernRouterClient",
+    "getTanstackSsrHydrationPromise",
+    "hasTanstackSsrHydrationRecord",
+    "hydrateTanstackRouter"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/dataMutation.js

@@ -29,198 +29,33 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     Form: ()=>Form,
-    RouteActionResponseError: ()=>RouteActionResponseError,
+    RouteActionResponseError: ()=>external_submitAction_js_namespaceObject.RouteActionResponseError,
     useFetcher: ()=>useFetcher
 });
 const jsx_runtime_namespaceObject = require("react/jsx-runtime");
 const react_router_namespaceObject = require("@tanstack/react-router");
 const external_react_namespaceObject = require("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;
-}
+const external_formData_js_namespaceObject = require("./formData.js");
+const external_submitAction_js_namespaceObject = require("./submitAction.js");
 function Form({ action, method = 'get', encType, reloadDocument, onSubmit, ...rest }) {
     const router = (0, react_router_namespaceObject.useRouter)();
     const handleSubmit = (0, external_react_namespaceObject.useCallback)(async (event)=>{
         onSubmit?.(event);
         if (event.defaultPrevented || reloadDocument) return;
         event.preventDefault();
-        const submitter = getSubmitter(event);
-        const formData = createFormDataFromSubmit({
+        const submitter = (0, external_formData_js_namespaceObject.getSubmitter)(event);
+        const formData = (0, external_formData_js_namespaceObject.createFormDataFromSubmit)({
             form: event.currentTarget,
             submitter
         });
-        const normalizedOptions = resolveSubmitOptionsFromForm({
+        const normalizedOptions = (0, external_formData_js_namespaceObject.resolveSubmitOptionsFromForm)({
             form: event.currentTarget,
             submitter,
             action,
             method,
             encType
         });
-        await submitRouteAction({
+        await (0, external_submitAction_js_namespaceObject.submitRouteAction)({
             router,
             target: formData,
             options: normalizedOptions
@@ -278,7 +113,7 @@ function useFetcher() {
         const isLoaderSubmit = 'get' === normalizedMethod;
         setRequestState(requestId, isLoaderSubmit ? 'loading' : 'submitting');
         try {
-            const result = await submitRouteAction({
+            const result = await (0, external_submitAction_js_namespaceObject.submitRouteAction)({
                 router,
                 target,
                 options,
@@ -304,12 +139,12 @@ function useFetcher() {
             onSubmit?.(event);
             if (event.defaultPrevented || reloadDocument) return;
             event.preventDefault();
-            const submitter = getSubmitter(event);
-            const formData = createFormDataFromSubmit({
+            const submitter = (0, external_formData_js_namespaceObject.getSubmitter)(event);
+            const formData = (0, external_formData_js_namespaceObject.createFormDataFromSubmit)({
                 form: event.currentTarget,
                 submitter
             });
-            const normalizedOptions = resolveSubmitOptionsFromForm({
+            const normalizedOptions = (0, external_formData_js_namespaceObject.resolveSubmitOptionsFromForm)({
                 form: event.currentTarget,
                 submitter,
                 action,

package/dist/cjs/runtime/formData.js

@@ -0,0 +1,116 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+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 appendSubmitterValue(formData, form, submitter) {
+    if (submitter.form !== form || submitter.disabled) return;
+    if (submitter instanceof HTMLInputElement && 'image' === submitter.type) {
+        const namePrefix = submitter.name ? `${submitter.name}.` : '';
+        formData.append(`${namePrefix}x`, '0');
+        formData.append(`${namePrefix}y`, '0');
+        return;
+    }
+    if (!submitter.name || 'button' === submitter.type || 'reset' === submitter.type) return;
+    formData.append(submitter.name, submitter.value);
+}
+function createFormDataFromSubmit({ form, submitter }) {
+    if (submitter) try {
+        return new FormData(form, submitter);
+    } catch  {}
+    const formData = new FormData(form);
+    if (submitter) appendSubmitterValue(formData, form, submitter);
+    return formData;
+}
+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
+    };
+}
+__webpack_require__.d(__webpack_exports__, {
+    createFormDataFromSubmit: ()=>createFormDataFromSubmit,
+    formDataToTextPlain: ()=>formDataToTextPlain,
+    formDataToUrlSearchParams: ()=>formDataToUrlSearchParams,
+    getSubmitter: ()=>getSubmitter,
+    resolveSubmitOptionsFromForm: ()=>resolveSubmitOptionsFromForm,
+    toFormData: ()=>toFormData
+});
+exports.createFormDataFromSubmit = __webpack_exports__.createFormDataFromSubmit;
+exports.formDataToTextPlain = __webpack_exports__.formDataToTextPlain;
+exports.formDataToUrlSearchParams = __webpack_exports__.formDataToUrlSearchParams;
+exports.getSubmitter = __webpack_exports__.getSubmitter;
+exports.resolveSubmitOptionsFromForm = __webpack_exports__.resolveSubmitOptionsFromForm;
+exports.toFormData = __webpack_exports__.toFormData;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createFormDataFromSubmit",
+    "formDataToTextPlain",
+    "formDataToUrlSearchParams",
+    "getSubmitter",
+    "resolveSubmitOptionsFromForm",
+    "toFormData"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/loaderBridge.js

@@ -29,7 +29,7 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     createRouteStaticData: ()=>createRouteStaticData,
-    isAbsoluteUrl: ()=>isAbsoluteUrl,
+    isAbsoluteUrl: ()=>isAbsoluteUrl_js_namespaceObject.isAbsoluteUrl,
     isRedirectResponse: ()=>isRedirectResponse,
     isResponse: ()=>isResponse,
     isTanstackRedirect: ()=>isTanstackRedirect,
@@ -38,6 +38,7 @@ __webpack_require__.d(__webpack_exports__, {
     throwTanstackRedirect: ()=>throwTanstackRedirect
 });
 const react_router_namespaceObject = require("@tanstack/react-router");
+const isAbsoluteUrl_js_namespaceObject = require("./shared/isAbsoluteUrl.js");
 function isResponse(value) {
     const record = value;
     return null != record && 'object' == typeof record && 'number' == typeof record.status && 'object' == typeof record.headers;
@@ -55,17 +56,9 @@ function isRedirectResponse(res) {
 function isTanstackRedirect(value) {
     return isResponse(value) && 'object' == typeof value.options;
 }
-function isAbsoluteUrl(value) {
-    try {
-        new URL(value);
-        return true;
-    } catch  {
-        return false;
-    }
-}
 function throwTanstackRedirect(location) {
     const target = location || '/';
-    if (isAbsoluteUrl(target)) throw (0, react_router_namespaceObject.redirect)({
+    if ((0, isAbsoluteUrl_js_namespaceObject.isAbsoluteUrl)(target)) throw (0, react_router_namespaceObject.redirect)({
         href: target
     });
     throw (0, react_router_namespaceObject.redirect)({
@@ -134,7 +127,10 @@ function modernLoaderToTanstack(opts, modernLoader) {
             const signal = getLoaderSignal(ctx);
             const baseRequest = ctx?.context?.request instanceof Request ? ctx.context.request : void 0;
             const href = getLoaderHref(ctx);
-            const request = void 0 !== baseRequest ? new Request(baseRequest, {
+            const request = void 0 !== baseRequest && '' !== href ? new Request(new URL(href, baseRequest.url).href, {
+                headers: baseRequest.headers,
+                signal
+            }) : void 0 !== baseRequest ? new Request(baseRequest, {
                 signal
             }) : new Request(href, {
                 signal