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

package/dist/esm-node/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/server.js

@@ -0,0 +1,396 @@
+import { prepareDocument } from "@modern-js/renderer-core/document";
+import { policyHeaders, responseHeaders, restrictDocumentCache, untilAborted } from "@modern-js/renderer-core/session";
+import { commitEventResponse, createRequestEvent, generateHydrationScript, isServer, renderToStream, ssr } from "@solidjs/web";
+import { provideRequestEvent } from "@solidjs/web/storage";
+import { Hydration, NoHydration, createComponent, createRoot, runWithOwner } from "solid-js";
+import { createFederationScope, provideFederation } from "./federation-context.js";
+import { withFederatedAssets } from "./federation-ssr.js";
+import { nativePromiseSerializationPlugin } from "./native-promise-serialization.js";
+const CSP_HEADERS = new Set([
+    "content-security-policy",
+    "content-security-policy-report-only",
+    "link"
+]);
+const requestEvents = new WeakMap();
+const nativeHeads = new WeakMap();
+function applicationRequestEvent(session) {
+    if ("solid" !== session.identity.renderer) throw new Error("The Solid adapter requires a Solid renderer identity.");
+    if ("node" !== session.platform.kind && "worker" !== session.platform.kind) throw new Error("Solid request context requires a Node or worker request platform.");
+    if (!isServer) throw new Error("The Solid server adapter must resolve @solidjs/web with a server (node or worker) condition.");
+    let event = requestEvents.get(session);
+    if (!event) {
+        event = createRequestEvent(session.request, {
+            locals: {
+                session,
+                bindings: session.platform.bindings
+            }
+        });
+        requestEvents.set(session, event);
+        nativeHeads.set(event, {
+            response: event.response,
+            headers: event.response.headers
+        });
+    }
+    return event;
+}
+async function runApplicationRequest(session, callback) {
+    let event;
+    try {
+        event = applicationRequestEvent(session);
+    } catch (error) {
+        session.fail(error);
+        throw error;
+    }
+    return await provideRequestEvent(event, async ()=>{
+        try {
+            return await untilAborted(callback(), session.signal);
+        } catch (error) {
+            session.fail(error);
+            throw error;
+        }
+    });
+}
+function ownData(object, key) {
+    const descriptor = Object.getOwnPropertyDescriptor(object, key);
+    if (!descriptor || !("value" in descriptor)) throw new TypeError("Solid response metadata must contain own data fields.");
+    return descriptor.value;
+}
+function readNativeHead(event) {
+    const native = nativeHeads.get(event);
+    if (!native || ownData(event, "response") !== native.response) throw new TypeError("The native Solid response stub cannot be replaced.");
+    const response = native.response;
+    const status = ownData(response, "status");
+    const statusText = ownData(response, "statusText");
+    if (void 0 !== status && ("number" != typeof status || !Number.isInteger(status) || status < 200 || status > 599)) throw new TypeError("A Solid response status must be an integer from 200 to 599.");
+    if (void 0 !== statusText && "string" != typeof statusText) throw new TypeError("A Solid response statusText must be a string.");
+    if (false !== ownData(response, "committed")) throw new Error("The native Solid response head is already committed.");
+    if (ownData(response, "headers") !== native.headers || Object.getPrototypeOf(native.headers) !== Headers.prototype) throw new TypeError("The native Solid response Headers cannot be replaced.");
+    for (const key of [
+        "append",
+        "delete",
+        "entries",
+        "forEach",
+        "get",
+        "getSetCookie",
+        "has",
+        "set",
+        Symbol.iterator
+    ])if (Object.getOwnPropertyDescriptor(native.headers, key)) throw new TypeError("The native Solid response Headers methods cannot be replaced.");
+    return {
+        status,
+        statusText,
+        headers: native.headers
+    };
+}
+function respondApplicationBody(session, body, hasSuppliedBody = false) {
+    return provideRequestEvent(applicationRequestEvent(session), ()=>{
+        try {
+            const event = applicationRequestEvent(session);
+            const policy = session.responsePolicy;
+            if (!policy || session.committedPolicy) throw new Error("Resolve an uncommitted Solid HTTP outcome before responding.");
+            const native = readNativeHead(event);
+            const original = policyHeaders(policy.headers);
+            const outgoing = policyHeaders(policy.headers);
+            let status = policy.status;
+            let statusText = policy.statusText;
+            let kind = policy.kind;
+            let bodyless = [
+                204,
+                205,
+                304
+            ].includes(status);
+            if ("document" === kind) {
+                status = native.status ?? status;
+                statusText = native.statusText ?? statusText;
+                native.headers.forEach((value, name)=>{
+                    if (CSP_HEADERS.has(name)) outgoing.append(name, value);
+                    else if ("set-cookie" !== name && "server-timing" !== name && "vary" !== name) outgoing.set(name, value);
+                });
+                const vary = [
+                    original.get("vary"),
+                    native.headers.get("vary")
+                ].flatMap((value)=>value?.split(",").map((part)=>part.trim()).filter(Boolean) ?? []);
+                if (vary.length) outgoing.set("vary", [
+                    ...new Set(vary)
+                ].join(", "));
+                for (const name of [
+                    "content-length",
+                    "content-encoding",
+                    "transfer-encoding"
+                ])outgoing.delete(name);
+                if (outgoing.has("location")) {
+                    status = [
+                        301,
+                        302,
+                        303,
+                        307,
+                        308
+                    ].includes(status) ? status : 302;
+                    bodyless = true;
+                } else bodyless = [
+                    204,
+                    205,
+                    304
+                ].includes(status);
+                if (bodyless) {
+                    kind = "terminal";
+                    outgoing.delete("content-type");
+                }
+            }
+            if (bodyless && hasSuppliedBody) throw new TypeError("A terminal Solid HTTP outcome cannot consume a document body.");
+            const cache = restrictDocumentCache({
+                ...policy,
+                kind,
+                status
+            }, [
+                native.headers
+            ], outgoing);
+            session.resolveResponse({
+                kind,
+                status,
+                statusText,
+                headers: responseHeaders(outgoing),
+                cache
+            });
+            const preview = commitEventResponse(new Response(bodyless ? null : body(), {
+                status,
+                statusText,
+                headers: outgoing
+            }), event);
+            const committedHeaders = preview.headers;
+            const finalCache = restrictDocumentCache({
+                ...policy,
+                kind,
+                status
+            }, [
+                native.headers
+            ], committedHeaders);
+            session.resolveResponse({
+                kind,
+                status,
+                statusText,
+                headers: responseHeaders(committedHeaders),
+                cache: finalCache
+            });
+            return session.respond(preview.body);
+        } catch (error) {
+            session.fail(error);
+            throw error;
+        }
+    });
+}
+function respondApplication(session, body) {
+    try {
+        return respondApplicationBody(session, ()=>body, null !== body);
+    } catch (error) {
+        session.fail(error);
+        throw error;
+    }
+}
+function respondApplicationResponse(session, response) {
+    try {
+        session.resolveResponse({
+            kind: "terminal",
+            status: response.status,
+            statusText: response.statusText,
+            headers: responseHeaders(response.headers),
+            cache: {
+                mode: "no-store"
+            }
+        });
+        return respondApplication(session, response.body);
+    } catch (error) {
+        session.fail(error);
+        throw error;
+    }
+}
+function getDocumentNonce(nonce, destination) {
+    const value = "string" == typeof nonce ? nonce : nonce?.[destination];
+    return false === value ? void 0 : value;
+}
+async function renderApplication(options) {
+    let federation;
+    try {
+        federation = createFederationScope(options.federation);
+    } catch (error) {
+        options.session.fail(error);
+        throw error;
+    }
+    return renderNativeApplication({
+        ...options,
+        view: provideFederation(federation, options.view)
+    }, federation);
+}
+async function renderNativeApplication(options, federation) {
+    const { session } = options;
+    let readable;
+    let consumed = false;
+    try {
+        const event = applicationRequestEvent(session);
+        if (session.responsePolicy?.kind !== "document" || [
+            204,
+            205,
+            304
+        ].includes(session.responsePolicy.status)) throw new Error("Resolve a document HTTP outcome before invoking the Solid renderer; terminal responses bypass rendering.");
+        session.startRendering();
+        let renderFailure;
+        const { promise: shell, resolve, reject } = Promise.withResolvers();
+        shell.catch(()=>{});
+        const failBeforeShell = ()=>reject(renderFailure ? renderFailure.error : session.signal.reason);
+        if (session.signal.aborted) failBeforeShell();
+        else session.signal.addEventListener("abort", failBeforeShell, {
+            once: true
+        });
+        readable = provideRequestEvent(event, ()=>runWithOwner(null, ()=>createRoot((dispose)=>{
+                    const nativeAbort = new AbortController();
+                    const abortNative = ()=>provideRequestEvent(event, ()=>{
+                            nativeAbort.abort(session.signal.reason);
+                        });
+                    session.signal.addEventListener("abort", abortNative, {
+                        once: true
+                    });
+                    session.registerCleanup(()=>provideRequestEvent(event, ()=>{
+                            session.signal.removeEventListener("abort", abortNative);
+                            if (session.committedPolicy?.kind === "terminal") nativeAbort.abort(new DOMException("The request resolved without a document body.", "AbortError"));
+                            dispose();
+                        }));
+                    if (session.signal.aborted) abortNative();
+                    const native = renderToStream(options.view, {
+                        ...options.document,
+                        manifest: withFederatedAssets(options.document?.manifest, federation),
+                        plugins: [
+                            nativePromiseSerializationPlugin
+                        ],
+                        signal: nativeAbort.signal,
+                        onCompleteShell () {
+                            session.signal.removeEventListener("abort", failBeforeShell);
+                            try {
+                                resolve(respondApplicationBody(session, ()=>{
+                                    consumed = true;
+                                    return native.readable;
+                                }));
+                            } catch (error) {
+                                reject(error);
+                                throw error;
+                            }
+                        },
+                        onError (error, context) {
+                            if ("failed" === context.handling) {
+                                renderFailure ??= {
+                                    error
+                                };
+                                session.fail(error);
+                            } else if ("completed" !== session.state && "failed" !== session.state && "aborted" !== session.state) session.markFallback();
+                            return options.onError?.(error, context);
+                        }
+                    });
+                    if (renderFailure) throw renderFailure.error;
+                    return native.readable;
+                }, {
+                    transparent: true
+                })));
+        return await shell;
+    } catch (error) {
+        session.fail(error);
+        throw error;
+    } finally{
+        if (readable && !consumed) readable.cancel().catch(()=>{});
+    }
+}
+function createDocumentParts(options, hydrating) {
+    const { session } = options;
+    const document = options.document ?? {};
+    const renderId = document.renderId ?? `${[
+        session.identity.appId,
+        session.identity.entryName,
+        session.identity.buildId
+    ].map((value)=>encodeURIComponent(value).replaceAll("'", "%27")).join(":")}:`;
+    if ("string" != typeof renderId || /[\s"'`=<>&]/u.test(renderId)) throw new TypeError("A Solid renderId cannot contain whitespace, quotes or HTML syntax.");
+    const script = getDocumentNonce(document.nonce, "script");
+    const style = getDocumentNonce(document.nonce, "style");
+    const parts = prepareDocument({
+        identity: session.identity,
+        documentId: renderId,
+        hydrating
+    }, {
+        rootId: document.rootId,
+        lang: document.lang,
+        nonce: {
+            script,
+            style
+        },
+        assets: document.assets,
+        inlineData: document.inlineData
+    });
+    return {
+        renderId,
+        lang: ` lang="${parts.lang}"`,
+        root: ` id="${parts.rootId}"`,
+        head: parts.headAssets + parts.bootstrap + (hydrating ? generateHydrationScript({
+            nonce: script
+        }) : ""),
+        modules: parts.entryScripts
+    };
+}
+async function renderDocumentApplication(options) {
+    try {
+        const parts = createDocumentParts(options, true);
+        const federation = createFederationScope(options.federation);
+        const view = provideFederation(federation, options.view);
+        return await renderNativeApplication({
+            session: options.session,
+            document: {
+                renderId: parts.renderId,
+                nonce: options.document?.nonce,
+                manifest: options.document?.manifest,
+                onHead: options.document?.onHead
+            },
+            onError: options.onError,
+            view: ()=>createComponent(NoHydration, {
+                    get children () {
+                        return ssr([
+                            "<!doctype html><html",
+                            "><head>",
+                            "</head><body><div",
+                            ">",
+                            "</div>",
+                            "</body></html>"
+                        ], parts.lang, ssr(parts.head), parts.root, createComponent(Hydration, {
+                            id: parts.renderId,
+                            get children () {
+                                return view();
+                            }
+                        }), ssr(parts.modules));
+                    }
+                })
+        }, federation);
+    } catch (error) {
+        options.session.fail(error);
+        throw error;
+    }
+}
+function renderCSRDocument(options) {
+    const { session } = options;
+    try {
+        if ("solid" !== session.identity.renderer || "node" !== session.platform.kind && "worker" !== session.platform.kind) throw new Error("The Solid CSR document requires a Solid Node or worker request session.");
+        if (session.responsePolicy?.kind !== "document" || [
+            204,
+            205,
+            304
+        ].includes(session.responsePolicy.status)) throw new Error("Terminal HTTP outcomes bypass the Solid CSR document.");
+        const parts = createDocumentParts(options, false);
+        const html = `<!doctype html><html${parts.lang}><head>${parts.head}</head><body><div${parts.root}></div>${parts.modules}</body></html>`;
+        return respondApplication(session, new ReadableStream({
+            start (controller) {
+                controller.enqueue(new TextEncoder().encode(html));
+                controller.close();
+            }
+        }, {
+            highWaterMark: 0
+        }));
+    } catch (error) {
+        session.fail(error);
+        throw error;
+    }
+}
+export { renderApplication, renderCSRDocument, renderDocumentApplication, respondApplication, respondApplicationResponse, runApplicationRequest };

package/dist/types/actions.d.ts

@@ -0,0 +1,45 @@
+import type { DecodedDataOutcome } from '@modern-js/renderer-core/data';
+import type { RendererIdentity } from '@modern-js/renderer-core/identity';
+import type { JSX } from '@solidjs/web';
+import type { Accessor } from 'solid-js';
+import type { AnyRouter } from './router-binding/index.js';
+export interface RouteActionOptions {
+    router: AnyRouter;
+    routeId: string;
+    rendererIdentity: RendererIdentity;
+    url?: string | URL;
+    fetch?: typeof globalThis.fetch;
+}
+export interface RouteAction {
+    readonly routeId: string;
+    readonly pending: Accessor<boolean>;
+    readonly outcome: Accessor<DecodedDataOutcome | undefined>;
+    readonly error: Accessor<Error | undefined>;
+    readonly url: Accessor<string>;
+    /** Cancellation and superseded submissions resolve without publishing stale data. */
+    submit(request: Request): Promise<DecodedDataOutcome | undefined>;
+    submitForm(form: HTMLFormElement, submitter?: HTMLElement | null): Promise<DecodedDataOutcome | undefined>;
+    cancel(): void;
+    dispose(): void;
+}
+/** An asynchronous action exposes its public failure to the form's owner. */
+export declare class RouteActionError extends Error {
+    readonly routeId: string;
+    readonly status: number;
+    readonly data: unknown;
+    readonly outcome: Extract<DecodedDataOutcome, {
+        kind: 'error' | 'not-found';
+    }>;
+    constructor(routeId: string, outcome: Extract<DecodedDataOutcome, {
+        kind: 'error' | 'not-found';
+    }>);
+}
+export declare function createRouteAction(options: RouteActionOptions): RouteAction;
+/** Bind a form to the closest native route without a second route-ID authority. */
+export declare function useRouteAction(): RouteAction;
+export type ActionFormProps = Omit<JSX.FormHTMLAttributes<HTMLFormElement>, 'action' | 'method' | 'onSubmit' | 'onSubmitCapture'> & {
+    action: RouteAction;
+    children?: JSX.Element;
+};
+/** Native controls produce the request body; the renderer owns data transport. */
+export declare function ActionForm(props: ActionFormProps): JSX.Element;

package/dist/types/application-router.d.ts

@@ -0,0 +1,5 @@
+import { type JSX } from '@solidjs/web';
+import type { AnyRouter, RegisteredRouter } from '@tanstack/router-core';
+import { type RouterProps } from './router-binding/RouterProvider.js';
+/** Native routing and head hooks share the same request/application provider. */
+export declare function ApplicationRouter<TRouter extends AnyRouter = RegisteredRouter, TDehydrated extends Record<string, unknown> = Record<string, unknown>>(props: Omit<RouterProps<TRouter, TDehydrated>, 'context'>): JSX.Element;

package/dist/types/client.d.ts

@@ -0,0 +1,23 @@
+import { type DocumentBootstrap } from '@modern-js/renderer-core/document';
+import type { NativeFederationBinding } from '@modern-js/renderer-core/federation';
+import type { RendererIdentity } from '@modern-js/renderer-core/identity';
+import type { JSX } from '@solidjs/web';
+import { hydrate } from '@solidjs/web';
+type NativeMountOptions = NonNullable<Parameters<typeof hydrate>[2]>;
+export type ApplicationMountElement = Parameters<typeof hydrate>[1];
+export type SolidDocumentBootstrap = DocumentBootstrap;
+/** Read the server's exact identity before creating a native router or owner. */
+export declare function readSolidDocumentBootstrap(document: Document, expectedIdentity: RendererIdentity): SolidDocumentBootstrap;
+/** The generated entry passes its bundler's native HMR disposal callback. */
+export interface ApplicationMountOptions {
+    renderId?: NativeMountOptions['renderId'];
+    onError?: NativeMountOptions['onError'];
+    hot?: {
+        dispose(callback: () => void): void;
+    };
+    /** This browser compilation's native Module Federation runtime. */
+    federation?: NativeFederationBinding;
+}
+export declare function mountApplication(view: () => JSX.Element, element: ApplicationMountElement, options?: ApplicationMountOptions): () => void;
+export declare function hydrateApplication(view: () => JSX.Element, element: ApplicationMountElement, options?: ApplicationMountOptions): () => void;
+export {};

package/dist/types/entry-application.d.ts

@@ -0,0 +1,10 @@
+import type { LocalisedUrlsOption } from '@modern-js/i18n-runtime-extensions/paths';
+import type { NativeI18nView } from '@modern-js/renderer-core/entry-client';
+import type { NativeRouterFactory } from '@modern-js/renderer-core/router';
+import type { JSX } from '@solidjs/web';
+import { type AnyRoute, type AnyRouter } from './router-binding/index.js';
+export type SolidI18nView = NativeI18nView<unknown, LocalisedUrlsOption>;
+/** The Solid route tree and router of a generated entry. */
+export declare const solidRouterFactory: NativeRouterFactory<AnyRoute, AnyRouter>;
+export declare function componentView(component: unknown, i18n?: SolidI18nView): () => JSX.Element;
+export declare function routerView(router: AnyRouter, i18n?: SolidI18nView): () => JSX.Element;

package/dist/types/entry-client.d.ts

@@ -0,0 +1,5 @@
+import type { LocalisedUrlsOption } from '@modern-js/i18n-runtime-extensions/paths';
+import { type NativeClientEntryOptions, type NativeI18nInstance } from '@modern-js/renderer-core/entry-client';
+export type SolidClientEntryOptions = NativeClientEntryOptions<NativeI18nInstance, LocalisedUrlsOption>;
+/** Start a generated Solid browser entry: mount, or hydrate the server document. */
+export declare function startNativeClient(options: SolidClientEntryOptions): void;