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

package/dist/esm/actions.js

@@ -0,0 +1,283 @@
+import { claimElement, getNextElement, getRequestEvent, runHydrationEvents, spread, template } 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 _tmpl$ = /* @__PURE__ */ template("<form>");
+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, {
+        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) {
+    const submit = (event)=>{
+        event.preventDefault();
+        props.action.submitForm(event.currentTarget, event.submitter);
+    };
+    var _el$ = getNextElement(_tmpl$);
+    claimElement(_el$);
+    spread(_el$, [
+        ()=>omit(props, "action"),
+        {
+            get action () {
+                return props.action.url();
+            },
+            method: "post",
+            get enctype () {
+                return props.enctype ?? "application/x-www-form-urlencoded";
+            },
+            onSubmit: submit
+        }
+    ], false);
+    runHydrationEvents();
+    return _el$;
+}
+export { ActionForm, RouteActionError, createRouteAction, useRouteAction };

package/dist/esm/application-router.js

@@ -0,0 +1,25 @@
+import { createComponent, 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")) throw new DataProtocolError("Set public Solid router context in createApplicationRouter; ApplicationRouter context overrides are unsupported");
+    const { router, ...rest } = props;
+    ownApplicationRouteData(router);
+    return createComponent(RouterContextProvider, mergeProps({
+        router
+    }, rest, {
+        children: ()=>[
+                createComponent(ApplicationHead, {}),
+                createComponent(Matches, {})
+            ]
+    }));
+}
+export { ApplicationRouter };

package/dist/esm/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/entry-application.js

@@ -0,0 +1,60 @@
+import { createComponent } from "@solidjs/web";
+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";
+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 ()=>createComponent(App, {});
+    return ()=>createComponent(I18nProvider, {
+            get instance () {
+                return i18n.instance;
+            },
+            get languages () {
+                return i18n.languages;
+            },
+            get localisedUrls () {
+                return i18n.localisedUrls;
+            },
+            get children () {
+                return createComponent(App, {});
+            }
+        });
+}
+function routerView(router, i18n) {
+    if (!i18n) return ()=>createComponent(ApplicationRouter, {
+            router
+        });
+    return ()=>createComponent(I18nProvider, {
+            get instance () {
+                return i18n.instance;
+            },
+            get languages () {
+                return i18n.languages;
+            },
+            get localisedUrls () {
+                return i18n.localisedUrls;
+            },
+            get children () {
+                return createComponent(ApplicationRouter, {
+                    router
+                });
+            }
+        });
+}
+export { componentView, routerView, solidRouterFactory };

package/dist/esm/entry-client.js

@@ -0,0 +1,23 @@
+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),
+        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 };

package/dist/esm/federation-context.js

@@ -0,0 +1,25 @@
+import { getFederationHost } from "@modern-js/renderer-core/federation";
+import { createComponent, createContext } from "solid-js";
+const FederationContext = createContext(Object.freeze({
+    instance: void 0
+}));
+function createFederationScope(binding) {
+    if (void 0 === binding) return;
+    const instance = getFederationHost(binding);
+    return void 0 === binding.hydrationModule ? {
+        instance
+    } : {
+        instance,
+        hydrationModule: binding.hydrationModule
+    };
+}
+function provideFederation(scope, view) {
+    if (!scope) return view;
+    return ()=>createComponent(FederationContext, {
+            value: scope,
+            get children () {
+                return view();
+            }
+        });
+}
+export { FederationContext, createFederationScope, provideFederation };

package/dist/esm/federation-ssr.js

@@ -0,0 +1,84 @@
+import { remoteBrowserAssets } from "@modern-js/renderer-core/federation";
+const FEDERATED_ASSET_PREFIX = "ultramodern-federation:";
+function federatedServerAssets(scope, id) {
+    const instance = scope?.instance;
+    const assets = instance && remoteBrowserAssets(instance, id);
+    if (!assets || !scope?.hydrationModule || !instance.name) return;
+    const hydration = `${scope.hydrationModule}?id=${encodeURIComponent(id)}&host=${encodeURIComponent(instance.name)}`;
+    return {
+        hydration,
+        assets
+    };
+}
+function federatedAssetKey(id) {
+    return `${FEDERATED_ASSET_PREFIX}${id}`;
+}
+function joinAssetPath(base, file) {
+    if (/^(?:[a-z][a-z0-9+.-]*:)?\/\//iu.test(file)) return file;
+    let prefix = "string" == typeof base && base ? base : "/";
+    if (!prefix.endsWith("/")) prefix += "/";
+    return prefix + (file.startsWith("/") ? file.slice(1) : file);
+}
+function resolveStaticAssets(manifest, key) {
+    if ("_base" === key || !Object.hasOwn(manifest, key)) return null;
+    const base = manifest._base;
+    const js = [];
+    const css = [];
+    let preloads;
+    const visited = new Set();
+    const walk = (name)=>{
+        if (visited.has(name) || "_base" === name) return;
+        visited.add(name);
+        const chunk = manifest[name];
+        if (!chunk) return;
+        js.push(joinAssetPath(base, chunk.file));
+        for (const file of chunk.css ?? [])css.push(joinAssetPath(base, file));
+        for (const link of chunk.preloads ?? []){
+            const href = "string" == typeof link.href && link.href;
+            if (href || "string" == typeof link.imagesrcset) {
+                preloads ??= [];
+                if (href) preloads.push({
+                    ...link,
+                    href: joinAssetPath(base, href)
+                });
+                else {
+                    const { href: _ignored, ...rest } = link;
+                    preloads.push(rest);
+                }
+            }
+        }
+        for (const dependency of chunk.imports ?? [])walk(dependency);
+    };
+    walk(key);
+    return preloads ? {
+        js,
+        css,
+        preloads
+    } : {
+        js,
+        css
+    };
+}
+function withFederatedAssets(manifest, scope) {
+    if (!scope?.hydrationModule || null === manifest || "object" != typeof manifest || "function" == typeof manifest.resolve) return manifest;
+    const modules = manifest;
+    const resolve = (key)=>{
+        if (!key.startsWith(FEDERATED_ASSET_PREFIX)) return resolveStaticAssets(modules, key);
+        const remote = federatedServerAssets(scope, key.slice(FEDERATED_ASSET_PREFIX.length));
+        if (!remote) return null;
+        return {
+            js: [
+                joinAssetPath(modules._base, remote.hydration),
+                ...remote.assets.js
+            ],
+            css: [
+                ...remote.assets.css
+            ]
+        };
+    };
+    return {
+        resolve,
+        resolveSync: resolve
+    };
+}
+export { FEDERATED_ASSET_PREFIX, federatedAssetKey, federatedServerAssets, withFederatedAssets };

package/dist/esm/federation.js

@@ -0,0 +1,83 @@
+import { loadFederatedModule } from "@modern-js/renderer-core/federation";
+import { isServer } from "@solidjs/web";
+import { FederationContext } from "./federation-context.js";
+import { federatedAssetKey, federatedServerAssets } from "./federation-ssr.js";
+import * as __rspack_external_solid_js_0ac0db99 from "solid-js";
+const DEFAULT_SERVER_TIMEOUT = 3e3;
+function withTimeout(promise, timeout, label) {
+    if (void 0 === timeout) return promise;
+    return new Promise((resolve, reject)=>{
+        const timer = setTimeout(()=>reject(new Error(`Remote module ${label} did not load within ${timeout}ms`)), timeout);
+        timer.unref?.();
+        promise.then((value)=>{
+            clearTimeout(timer);
+            resolve(value);
+        }, (error)=>{
+            clearTimeout(timer);
+            reject(error);
+        });
+    });
+}
+function afterHydration(callback) {
+    const { sharedConfig } = __rspack_external_solid_js_0ac0db99;
+    const onHydrationEnd = sharedConfig?.onHydrationEnd;
+    if (onHydrationEnd) onHydrationEnd(callback);
+    else queueMicrotask(callback);
+}
+function federatedComponent(remote, options = {}) {
+    if ("string" == typeof remote ? !/^[^/]+\/.+/u.test(remote) : "function" != typeof remote) throw new TypeError("federatedComponent requires a remote id such as 'remote/Widget' or a loader");
+    if (void 0 !== options.timeout && (!Number.isFinite(options.timeout) || options.timeout <= 0)) throw new TypeError("federatedComponent timeout must be a positive number of milliseconds");
+    const id = "string" == typeof remote ? remote : void 0;
+    const timeout = options.timeout ?? (isServer ? DEFAULT_SERVER_TIMEOUT : void 0);
+    const load = (scope)=>(0, __rspack_external_solid_js_0ac0db99.lazy)(async ()=>{
+            if (isServer && !id) throw new Error("A federatedComponent loader renders in the browser only; use a remote id to server-render it");
+            const module = await withTimeout(Promise.resolve().then(()=>id ? loadFederatedModule(scope.instance, id) : remote()), timeout, id ?? "loader");
+            const component = module?.default;
+            if ("function" != typeof component) throw new TypeError("A federated Solid module must default-export a component");
+            if (!isServer || !id) return {
+                default: component
+            };
+            if (!federatedServerAssets(scope, id)) throw new Error(`Cannot server-render ${id}: the host has no server federation state for its browser assets`);
+            return {
+                default: component,
+                $$moduleUrl: federatedAssetKey(id)
+            };
+        });
+    const remotes = new WeakMap();
+    const fallback = ()=>options.fallback?.();
+    return (props)=>{
+        const scope = (0, __rspack_external_solid_js_0ac0db99.useContext)(FederationContext);
+        const Remote = remotes.get(scope) ?? load(scope);
+        remotes.set(scope, Remote);
+        const remoteView = ()=>(0, __rspack_external_solid_js_0ac0db99.createComponent)(Remote, props);
+        const [retried, retry] = (0, __rspack_external_solid_js_0ac0db99.createSignal)(false);
+        const recover = (error)=>{
+            if (isServer) return fallback();
+            if ((0, __rspack_external_solid_js_0ac0db99.isHydrating)()) {
+                let active = true;
+                (0, __rspack_external_solid_js_0ac0db99.onCleanup)(()=>{
+                    active = false;
+                });
+                afterHydration(()=>{
+                    if (active) retry(true);
+                });
+                return fallback();
+            }
+            throw error();
+        };
+        return (0, __rspack_external_solid_js_0ac0db99.createComponent)(__rspack_external_solid_js_0ac0db99.Loading, {
+            get fallback () {
+                return fallback();
+            },
+            get children () {
+                return retried() ? remoteView() : (0, __rspack_external_solid_js_0ac0db99.createComponent)(__rspack_external_solid_js_0ac0db99.Errored, {
+                    fallback: recover,
+                    get children () {
+                        return remoteView();
+                    }
+                });
+            }
+        });
+    };
+}
+export { federatedComponent };

package/dist/esm/i18n/I18nProvider.js

@@ -0,0 +1,33 @@
+import { createComponent } from "@solidjs/web";
+import { I18nContext } from "./context.js";
+import * as __rspack_external_solid_js_0ac0db99 from "solid-js";
+function I18nProvider(props) {
+    const [language, setLanguage] = __rspack_external_solid_js_0ac0db99.createSignal(props.instance.language);
+    __rspack_external_solid_js_0ac0db99.createEffect(()=>props.instance, (instance)=>{
+        setLanguage(instance.language);
+        const handleLanguageChanged = (lng)=>setLanguage(lng);
+        instance.on?.("languageChanged", handleLanguageChanged);
+        return ()=>{
+            instance.off?.("languageChanged", handleLanguageChanged);
+        };
+    });
+    const value = {
+        get instance () {
+            return props.instance;
+        },
+        get languages () {
+            return props.languages;
+        },
+        get localisedUrls () {
+            return props.localisedUrls;
+        },
+        language
+    };
+    return createComponent(I18nContext, {
+        value,
+        get children () {
+            return props.children;
+        }
+    });
+}
+export { I18nProvider };