@bleedingdev/modern-js-renderer-solid 0.0.0-stage → 3.9.3-ultramodern.10

package/dist/esm/router.js

@@ -0,0 +1,187 @@
+import { DataProtocolError } from "@modern-js/renderer-core/data";
+import { RouteDataError, loadFileSystemRoute, matchApplicationRouteIds, matchApplicationRoutes, nativeRoutePath, resolveRouteData, selectApplicationDataRoute, splitFileSystemRoutes, untilAborted } from "@modern-js/renderer-core/router";
+import { createApplicationRouter, createRouteCompletionScope, registerRouteCompletionScope } from "./route-completion.js";
+import { restoreRouteDataError } from "./route-data-error.js";
+import { Outlet, createRootRoute, createRoute, isNotFound, isRedirect, notFound, preparePublicContextData, preparePublicLoaderData, preparePublicMatchError, redirect } from "./router-binding/index.js";
+export * from "./router-binding/index.js";
+function isPublicRecord(value) {
+    if (!value || "object" != typeof value) return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || null === prototype;
+}
+function resolveApplicationRedirect(router) {
+    const result = router._serverResult;
+    const value = result?.type === "redirect" ? result.redirect : void 0;
+    return isRedirect(value) ? router.resolveRedirect(value) : void 0;
+}
+function getApplicationStatus(router) {
+    const result = router._serverResult;
+    if (!result) throw new Error("Load the native Solid router before resolving HTTP status");
+    return "render" === result.type ? result.status : result.redirect.status;
+}
+function router_resolveRouteData(routeId, outcome, project) {
+    return resolveRouteData({
+        redirect: redirect,
+        notFound: notFound
+    }, routeId, outcome, project);
+}
+function createFileSystemRouteTree(routes, modules, options = {}) {
+    const { root: rootDescriptor, children } = splitFileSystemRoutes(routes);
+    const privateRoots = options.context && ("object" == typeof options.context || "function" == typeof options.context) ? [
+        options.context
+    ] : [];
+    const completionScope = createRouteCompletionScope(privateRoots, options.session);
+    const moduleFields = new Set([
+        "component",
+        "pendingComponent",
+        "errorComponent",
+        "notFoundComponent",
+        "head",
+        "beforeLoad",
+        "context",
+        "validateSearch"
+    ]);
+    function projectModuleContext(authored, source) {
+        try {
+            const value = preparePublicContextData(authored, options.session ?? completionScope.hydrationOwner, [
+                options.context
+            ]);
+            if ("context" === source && void 0 !== value && !isPublicRecord(value)) throw new DataProtocolError("Native Solid route context must return a synchronous public record");
+            if ("search" === source && !isPublicRecord(value)) throw new DataProtocolError("Native Solid search validation must return a public record");
+            return value;
+        } catch (error) {
+            options.session?.fail(error);
+            throw error;
+        }
+    }
+    function routeModuleOptions(id) {
+        const module = modules[id] ?? {};
+        const prototype = Object.getPrototypeOf(module);
+        if (prototype !== Object.prototype && null !== prototype) throw new DataProtocolError("Native Solid filesystem route modules require plain option records");
+        for (const key of Reflect.ownKeys(module)){
+            const descriptor = Object.getOwnPropertyDescriptor(module, key);
+            if ("string" != typeof key || !moduleFields.has(key) || descriptor.get || descriptor.set) throw new DataProtocolError("Unsupported native Solid filesystem route option; use the declared public route module contract");
+        }
+        const beforeLoad = module.beforeLoad;
+        const validateSearch = module.validateSearch;
+        const context = module.context;
+        const contextOptions = context ? {
+            context (...args) {
+                return projectModuleContext(context(...args), "context");
+            }
+        } : {};
+        const searchOptions = validateSearch ? {
+            validateSearch (search) {
+                return projectModuleContext(validateSearch(search), "search");
+            }
+        } : {};
+        if (!beforeLoad) return {
+            ...module,
+            ...searchOptions,
+            ...contextOptions
+        };
+        return {
+            ...module,
+            ...searchOptions,
+            ...contextOptions,
+            beforeLoad: async (...args)=>{
+                const signal = args[0]?.abortController?.signal;
+                let value;
+                try {
+                    value = await (signal ? untilAborted(beforeLoad(...args), signal) : beforeLoad(...args));
+                } catch (error) {
+                    if (signal?.aborted) throw error;
+                    if (isRedirect(error)) throw error;
+                    let projected;
+                    try {
+                        projected = isNotFound(error) ? preparePublicContextData(error, options.session, [
+                            options.context
+                        ]) : preparePublicMatchError(error, options.session, [
+                            options.context
+                        ]);
+                    } catch (invalid) {
+                        options.session?.fail(invalid);
+                        throw invalid;
+                    }
+                    if (isNotFound(projected)) throw projected;
+                    if (projected && "object" == typeof projected && Object.getOwnPropertyDescriptor(projected, "kind")?.value === "ultramodern-route-data-error") throw Object.freeze(restoreRouteDataError(projected));
+                    const message = projected && "object" == typeof projected ? Object.getOwnPropertyDescriptor(projected, "message")?.value : void 0;
+                    const name = projected && "object" == typeof projected ? Object.getOwnPropertyDescriptor(projected, "name")?.value : void 0;
+                    const diagnostic = new Error("string" == typeof message ? message : "Unexpected Server Error");
+                    diagnostic.name = "string" == typeof name ? name : "Error";
+                    if (projected && "object" == typeof projected) for (const key of [
+                        "cause",
+                        "stack"
+                    ]){
+                        const descriptor = Object.getOwnPropertyDescriptor(projected, key);
+                        if (descriptor && !descriptor.get && !descriptor.set) Object.defineProperty(diagnostic, key, {
+                            value: descriptor.value,
+                            configurable: true,
+                            writable: true
+                        });
+                    }
+                    throw Object.freeze(diagnostic);
+                }
+                return projectModuleContext(value, "beforeLoad");
+            }
+        };
+    }
+    function loaderOptions(route) {
+        const loadRoute = options.loadRoute;
+        if (!(route.modules?.data || route.modules?.clientData) || !loadRoute) return {};
+        return {
+            loader: async (match)=>{
+                const { outcome, request, signal } = await loadFileSystemRoute(route, loadRoute, options, match);
+                options.onOutcome?.(route.id, outcome);
+                const generation = completionScope.begin(signal, ()=>match.abortController.abort());
+                const owner = options.session ?? generation.owner;
+                const project = (value)=>{
+                    try {
+                        return preparePublicLoaderData(value, owner, [
+                            options.context,
+                            request
+                        ]);
+                    } catch (error) {
+                        owner.fail(error);
+                        throw error;
+                    }
+                };
+                const value = router_resolveRouteData(route.id, outcome, project);
+                generation.publish(value, "completion" in outcome ? outcome.completion : void 0);
+                return value;
+            }
+        };
+    }
+    const root = createRootRoute({
+        ...routeModuleOptions(rootDescriptor?.id ?? ""),
+        component: completionScope.component(modules[rootDescriptor?.id ?? ""]?.component ?? Outlet),
+        staticData: {
+            ultramodernRouteId: rootDescriptor?.id
+        },
+        ...rootDescriptor ? loaderOptions(rootDescriptor) : {}
+    });
+    function bind(route, parent, inheritedErrorComponent) {
+        const errorComponent = modules[route.id]?.errorComponent ?? inheritedErrorComponent;
+        const native = createRoute({
+            getParentRoute: ()=>parent,
+            ...nativeRoutePath(route),
+            ...routeModuleOptions(route.id),
+            ...errorComponent ? {
+                errorComponent
+            } : {},
+            component: completionScope.component(modules[route.id]?.component ?? Outlet),
+            staticData: {
+                ultramodernRouteId: route.id
+            },
+            ...loaderOptions(route)
+        });
+        return native.addChildren(route.children.map((child)=>bind(child, native, errorComponent)));
+    }
+    const rootErrorComponent = modules[rootDescriptor?.id ?? ""]?.errorComponent;
+    const tree = root.addChildren(children.map((route)=>bind(route, root, rootErrorComponent)));
+    registerRouteCompletionScope(tree, completionScope);
+    return tree;
+}
+export { ActionForm, RouteActionError, createRouteAction, useRouteAction } from "./actions.js";
+export { ApplicationRouter } from "./application-router.js";
+export { RouteDataError, createApplicationRouter, createFileSystemRouteTree, getApplicationStatus, matchApplicationRouteIds, matchApplicationRoutes, resolveApplicationRedirect, router_resolveRouteData as resolveRouteData, selectApplicationDataRoute };

package/dist/esm-node/actions.js

@@ -0,0 +1,263 @@
+import { getRequestEvent, ssrElement, ssrElementAttribute } from "@solidjs/web";
+import { createDataClient } from "@modern-js/renderer-core/data";
+import { assertRendererIdentity, identityCacheKey } from "@modern-js/renderer-core/identity";
+import { createSignal, getOwner, omit, onCleanup, untrack } from "solid-js";
+import { redirect, useMatch, useRouter } from "./router-binding/index.js";
+import { preparePublicLoaderData, preparePublicMatchError } from "./router-binding/publicMatchData.js";
+var _sk$ = (k)=>"action" === k || "method" === k || "enctype" === k;
+class RouteActionError extends Error {
+    constructor(routeId, outcome){
+        super("error" === outcome.kind ? outcome.error.message : "Action route not found");
+        this.name = "error" === outcome.kind ? outcome.error.name : "RouteNotFound";
+        this.routeId = routeId;
+        this.status = outcome.status;
+        this.data = "error" === outcome.kind ? outcome.data : outcome.value;
+        this.outcome = outcome;
+        Reflect.deleteProperty(this, "stack");
+        const stack = "error" === outcome.kind ? Object.getOwnPropertyDescriptor(outcome.error, "stack")?.value : void 0;
+        if ("string" == typeof stack) this.stack = stack;
+        Object.freeze(this);
+    }
+}
+function actionFailure(cause, owner, privateContexts = []) {
+    let projection;
+    try {
+        projection = preparePublicMatchError(cause instanceof Error ? cause : new Error("The Solid route action failed", {
+            cause
+        }), owner, privateContexts);
+    } catch  {
+        projection = Object.freeze({
+            name: "DataProtocolError",
+            message: "Invalid public Solid action error"
+        });
+    }
+    const nested = "error" in projection ? projection.error : void 0;
+    const diagnostic = nested && "object" == typeof nested ? nested : projection;
+    const failure = new Error("string" == typeof diagnostic.message && "Unexpected Server Error" !== diagnostic.message ? diagnostic.message : "The Solid route action failed", Object.hasOwn(diagnostic, "cause") ? {
+        cause: diagnostic.cause
+    } : void 0);
+    failure.name = "string" == typeof diagnostic.name ? diagnostic.name : "Error";
+    Reflect.deleteProperty(failure, "stack");
+    if ("string" == typeof diagnostic.stack) failure.stack = diagnostic.stack;
+    return Object.freeze(failure);
+}
+function actionOutcome(result, owner, privateContexts) {
+    if ("success" !== result.kind) return preparePublicLoaderData(result, owner, privateContexts);
+    return Object.freeze({
+        kind: "success",
+        value: preparePublicLoaderData(result.value, owner, privateContexts),
+        status: result.status
+    });
+}
+function routerIdentity(router) {
+    const context = router.options.context;
+    if (context?.ultramodern === void 0) return;
+    const identity = context.ultramodern?.rendererIdentity;
+    if (!identity) throw new Error("Solid router context requires its renderer identity");
+    identityCacheKey(identity);
+    return identity;
+}
+function createRouteAction(options) {
+    const { router, routeId } = options;
+    if (!routeId) throw new Error("A Solid action requires its filesystem route ID");
+    identityCacheKey(options.rendererIdentity);
+    if ("solid" !== options.rendererIdentity.renderer) throw new Error("A Solid action requires the Solid renderer identity");
+    const configuredIdentity = routerIdentity(router);
+    if (configuredIdentity) assertRendererIdentity(options.rendererIdentity, configuredIdentity);
+    const identity = Object.freeze({
+        ...options.rendererIdentity
+    });
+    const client = createDataClient(routeId, identity, options.fetch ? {
+        fetch: options.fetch
+    } : {});
+    const requestURL = getRequestEvent()?.request.url;
+    const url = ()=>{
+        const base = "u" < typeof window ? requestURL : window.location.href;
+        const location = options.url ?? router.state.location.publicHref;
+        if (!base && !URL.canParse(String(location))) throw new Error("A server Solid action requires its native request URL");
+        return new URL(location, base).href;
+    };
+    const [pending, setPending] = createSignal(false);
+    const [outcome, setOutcome] = createSignal();
+    const [error, setError] = createSignal();
+    let active;
+    let disposed = false;
+    function cancel() {
+        const current = active;
+        if (!current) return;
+        active = void 0;
+        current.abort(new DOMException("The action was cancelled", "AbortError"));
+        setPending(false);
+    }
+    function dispose() {
+        if (disposed) return;
+        disposed = true;
+        cancel();
+    }
+    function submit(request) {
+        if (disposed) throw new Error("The Solid action owner has been disposed");
+        if ("GET" === request.method || "HEAD" === request.method) throw new Error("A Solid action requires a mutation Request");
+        cancel();
+        const controller = new AbortController();
+        active = controller;
+        const signal = controller.signal;
+        const abortRequest = ()=>controller.abort(request.signal.reason);
+        if (request.signal.aborted) abortRequest();
+        else request.signal.addEventListener("abort", abortRequest, {
+            once: true
+        });
+        const current = ()=>active === controller && !signal.aborted && !disposed;
+        const privateContexts = [
+            router.options.context,
+            request
+        ];
+        const owner = {
+            signal,
+            fail (failure) {
+                if (!current()) return;
+                setError(actionFailure(failure, owner, privateContexts));
+                controller.abort(failure);
+            }
+        };
+        setOutcome(void 0);
+        setError(void 0);
+        setPending(true);
+        const cancelled = Symbol("cancelled action");
+        let resolveCancellation;
+        const cancellation = new Promise((resolve)=>{
+            resolveCancellation = resolve;
+        });
+        const abort = ()=>{
+            if (active === controller) {
+                active = void 0;
+                setPending(false);
+            }
+            resolveCancellation(cancelled);
+        };
+        if (signal.aborted) abort();
+        else signal.addEventListener("abort", abort, {
+            once: true
+        });
+        return (async ()=>{
+            try {
+                if (!current()) return;
+                const result = await Promise.race([
+                    client.action({
+                        request: new Request(request, {
+                            signal
+                        })
+                    }),
+                    cancellation
+                ]);
+                if (result === cancelled || !current()) return;
+                const publicResult = actionOutcome(result, owner, privateContexts);
+                setOutcome(publicResult);
+                if (await Promise.race([
+                    Promise.resolve(result.completion),
+                    cancellation
+                ]) === cancelled || !current()) return;
+                if ("error" === publicResult.kind || "not-found" === publicResult.kind) setError(new RouteActionError(routeId, publicResult));
+                else if ("redirect" === result.kind) {
+                    if (307 === result.status || 308 === result.status || (301 === result.status || 302 === result.status) && "POST" !== request.method) throw new Error(`A native action redirect must not preserve the method (HTTP ${result.status} after ${request.method}); redirect with 303 to navigate after the mutation`);
+                    const resolved = router.resolveRedirect(redirect({
+                        href: new URL(result.location, request.url).href,
+                        statusCode: result.status
+                    }));
+                    const navigation = router.navigate({
+                        ...resolved.options,
+                        replace: true
+                    });
+                    const refresh = resolved.options.reloadDocument ? Promise.resolve() : router.invalidate({
+                        sync: true
+                    });
+                    await Promise.race([
+                        Promise.all([
+                            navigation,
+                            refresh
+                        ]),
+                        cancellation
+                    ]);
+                } else if (result.status < 400) await Promise.race([
+                    router.invalidate({
+                        sync: true
+                    }),
+                    cancellation
+                ]);
+                return current() ? publicResult : void 0;
+            } catch (failure) {
+                owner.fail(failure);
+                return;
+            } finally{
+                request.signal.removeEventListener("abort", abortRequest);
+                signal.removeEventListener("abort", abort);
+                if (active === controller) {
+                    active = void 0;
+                    setPending(false);
+                }
+            }
+        })();
+    }
+    async function submitForm(form, submitter) {
+        try {
+            const button = submitter instanceof HTMLButtonElement || submitter instanceof HTMLInputElement ? submitter : void 0;
+            const method = button?.hasAttribute("formmethod") ? button.formMethod : form.method;
+            if ("post" !== method.toLowerCase()) throw new Error("A Solid action form requires method=\"post\"");
+            const target = button?.hasAttribute("formtarget") ? button.formTarget : form.target;
+            if (target && "_self" !== target.toLowerCase()) throw new Error("A Solid action form requires the current browsing context");
+            const destination = button?.hasAttribute("formaction") ? button.formAction : form.action;
+            const formData = new FormData(form, button);
+            const encoding = button?.hasAttribute("formenctype") ? button.formEnctype : form.enctype;
+            let body;
+            if ("multipart/form-data" === encoding) body = formData;
+            else if ("application/x-www-form-urlencoded" === encoding) {
+                const encoded = new URLSearchParams();
+                for (const [name, value] of formData)encoded.append(name, "string" == typeof value ? value : value.name);
+                body = encoded;
+            } else throw new Error(`Unsupported Solid action form encoding: ${encoding}`);
+            return await submit(new Request(new URL(destination || url(), url()), {
+                method: "POST",
+                body,
+                credentials: "same-origin"
+            }));
+        } catch (failure) {
+            if (!disposed) setError(actionFailure(failure, void 0, [
+                router.options.context
+            ]));
+            return;
+        }
+    }
+    if (getOwner()) onCleanup(dispose);
+    return Object.freeze({
+        routeId,
+        pending,
+        outcome,
+        error,
+        url,
+        submit,
+        submitForm,
+        cancel,
+        dispose
+    });
+}
+function useRouteAction() {
+    const router = useRouter();
+    if (!router) throw new Error("useRouteAction requires a native Solid router");
+    const identity = routerIdentity(router);
+    if (!identity) throw new Error("useRouteAction requires the application renderer identity");
+    const match = useMatch({
+        strict: false
+    });
+    const routeMatch = untrack(match);
+    const route = router.routesById[routeMatch.routeId];
+    const routeId = route?.options.staticData?.ultramodernRouteId;
+    if (!routeId) throw new Error("useRouteAction requires a native filesystem route");
+    return createRouteAction({
+        router,
+        routeId,
+        rendererIdentity: identity
+    });
+}
+function ActionForm(props) {
+    return ssrElement("form", ()=>omit(props, "action"), void 0, true, _sk$, ()=>ssrElementAttribute("action", props.action.url()) + " method=\"post\"" + ssrElementAttribute("enctype", props.enctype ?? "application/x-www-form-urlencoded"));
+}
+export { ActionForm, RouteActionError, createRouteAction, useRouteAction };

package/dist/esm-node/application-router.js

@@ -0,0 +1,30 @@
+import { getRequestEvent, mergeProps, useHead } from "@solidjs/web";
+import { DataProtocolError } from "@modern-js/renderer-core/data";
+import { ownApplicationRouteData } from "./route-completion.js";
+import { toHeadTags, useTags } from "./router-binding/headContentUtils.js";
+import { Matches } from "./router-binding/Matches.js";
+import { RouterContextProvider } from "./router-binding/RouterProvider.js";
+function ApplicationHead() {
+    const tags = useTags();
+    useHead(()=>toHeadTags(tags()));
+    return null;
+}
+function ApplicationRouter(props) {
+    if (Object.hasOwn(props, "context")) {
+        const error = new DataProtocolError("Set public Solid router context in createApplicationRouter; ApplicationRouter context overrides are unsupported");
+        const session = getRequestEvent()?.locals.session;
+        session?.fail(error);
+        throw error;
+    }
+    const { router, ...rest } = props;
+    ownApplicationRouteData(router);
+    return RouterContextProvider(mergeProps({
+        router
+    }, rest, {
+        children: ()=>[
+                ApplicationHead(),
+                Matches({})
+            ]
+    }));
+}
+export { ApplicationRouter };

package/dist/esm-node/client.js

@@ -0,0 +1,49 @@
+import { readDocumentBootstrap } from "@modern-js/renderer-core/document";
+import { hydrate, render } from "@solidjs/web";
+import { runWithOwner } from "solid-js";
+import { createFederationScope, provideFederation } from "./federation-context.js";
+function readSolidDocumentBootstrap(document, expectedIdentity) {
+    if ("solid" !== expectedIdentity.renderer) throw new Error("The Solid document requires a Solid renderer identity");
+    const { identity, documentId, hydrating } = readDocumentBootstrap(document, expectedIdentity);
+    return {
+        identity,
+        documentId,
+        hydrating
+    };
+}
+const applications = new WeakSet();
+function createApplication(view, element, options, hydrating) {
+    if (applications.has(element)) throw new Error("A Solid application already owns this mount element");
+    let nativeDispose;
+    let disposed = false;
+    applications.add(element);
+    const dispose = ()=>{
+        if (disposed) return;
+        disposed = true;
+        try {
+            nativeDispose?.();
+        } finally{
+            applications.delete(element);
+        }
+    };
+    try {
+        const nativeOptions = {
+            renderId: options.renderId,
+            onError: options.onError
+        };
+        const root = provideFederation(createFederationScope(options.federation), view);
+        nativeDispose = runWithOwner(null, ()=>hydrating ? hydrate(root, element, nativeOptions) : render(root, element, void 0, nativeOptions));
+        options.hot?.dispose(dispose);
+        return dispose;
+    } catch (error) {
+        dispose();
+        throw error;
+    }
+}
+function mountApplication(view, element, options = {}) {
+    return createApplication(view, element, options, false);
+}
+function hydrateApplication(view, element, options = {}) {
+    return createApplication(view, element, options, true);
+}
+export { hydrateApplication, mountApplication, readSolidDocumentBootstrap };

package/dist/esm-node/entry-application.js

@@ -0,0 +1,110 @@
+import { ApplicationRouter } from "./application-router.js";
+import { I18nProvider } from "./i18n/I18nProvider.js";
+import { createApplicationRouter } from "./route-completion.js";
+import { createFileSystemRouteTree } from "./router.js";
+import { createMemoryHistory } from "./router-binding/index.js";
+var _m$ = Symbol(), _m$2 = Symbol();
+var _d$ = {
+    get () {
+        const i18n = this[_m$];
+        return i18n.instance;
+    },
+    enumerable: true,
+    configurable: true
+}, _d$2 = {
+    get () {
+        const i18n = this[_m$];
+        return i18n.languages;
+    },
+    enumerable: true,
+    configurable: true
+}, _d$3 = {
+    get () {
+        const i18n = this[_m$];
+        return i18n.localisedUrls;
+    },
+    enumerable: true,
+    configurable: true
+}, _d$4 = {
+    get () {
+        const App = this[_m$2];
+        return App({});
+    },
+    enumerable: true,
+    configurable: true
+};
+function _P$(_p, _p2) {
+    this[_m$] = _p;
+    this[_m$2] = _p2;
+    Object.defineProperty(this, "instance", _d$);
+    Object.defineProperty(this, "languages", _d$2);
+    Object.defineProperty(this, "localisedUrls", _d$3);
+    Object.defineProperty(this, "children", _d$4);
+}
+_P$.prototype = Object.prototype;
+var _d$5 = {
+    get () {
+        const i18n = this[_m$];
+        return i18n.instance;
+    },
+    enumerable: true,
+    configurable: true
+}, _d$6 = {
+    get () {
+        const i18n = this[_m$];
+        return i18n.languages;
+    },
+    enumerable: true,
+    configurable: true
+}, _d$7 = {
+    get () {
+        const i18n = this[_m$];
+        return i18n.localisedUrls;
+    },
+    enumerable: true,
+    configurable: true
+}, _d$8 = {
+    get () {
+        const router = this[_m$2];
+        return ApplicationRouter({
+            router
+        });
+    },
+    enumerable: true,
+    configurable: true
+};
+function _P$2(_p3, _p4) {
+    this[_m$] = _p3;
+    this[_m$2] = _p4;
+    Object.defineProperty(this, "instance", _d$5);
+    Object.defineProperty(this, "languages", _d$6);
+    Object.defineProperty(this, "localisedUrls", _d$7);
+    Object.defineProperty(this, "children", _d$8);
+}
+_P$2.prototype = Object.prototype;
+const solidRouterFactory = {
+    routeTree: (routes, modules, options)=>createFileSystemRouteTree(routes, modules, options),
+    router: ({ location, ...options })=>createApplicationRouter({
+            ...options,
+            ...location ? {
+                origin: location.origin,
+                history: createMemoryHistory({
+                    initialEntries: [
+                        location.href
+                    ]
+                })
+            } : {}
+        })
+};
+function componentView(component, i18n) {
+    const App = component;
+    if (!i18n) return ()=>App({});
+    return ()=>I18nProvider(new _P$(i18n, App));
+}
+function routerView(router, i18n) {
+    if (!i18n) return ()=>ApplicationRouter({
+            router
+        });
+    return ()=>I18nProvider(new _P$2(i18n, router));
+}
+export { componentView, routerView, solidRouterFactory };

package/dist/esm-node/entry-client.js

@@ -0,0 +1,24 @@
+import { startNativeClientEntry } from "@modern-js/renderer-core/entry-client";
+import { createNativeRouter } from "@modern-js/renderer-core/router";
+import { hydrateApplication, mountApplication, readSolidDocumentBootstrap } from "./client.js";
+import { componentView, routerView, solidRouterFactory } from "./entry-application.js";
+function startNativeClient(options) {
+    startNativeClientEntry(options, {
+        readBootstrap: readSolidDocumentBootstrap,
+        createRouter: (application, routerOptions)=>createNativeRouter(application, routerOptions, solidRouterFactory),
+        disposeRouter: (router)=>router.history.destroy(),
+        async prepareRouter (router, hydrating) {
+            if (!hydrating) await router.load();
+        },
+        async start ({ root, bootstrap, load }) {
+            const view = await load();
+            return (bootstrap?.hydrating ? hydrateApplication : mountApplication)("component" === view.kind ? componentView(view.component, view.i18n) : routerView(view.router, view.i18n), root, {
+                ...bootstrap ? {
+                    renderId: bootstrap.documentId
+                } : {},
+                federation: options.federation
+            });
+        }
+    });
+}
+export { startNativeClient };