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

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

@@ -0,0 +1,47 @@
+import { dataMetadataToDocumentPolicy, mergeDataResponseIntoResponse, mergeDataResponseMetadata } from "@modern-js/renderer-core/data";
+import { createNativeServerEntry } from "@modern-js/renderer-core/entry-server";
+import { createNativeRouter } from "@modern-js/renderer-core/router";
+import { componentView, routerView, solidRouterFactory } from "./entry-application.js";
+import { validateSolidModuleManifest } from "./manifest.js";
+import { getApplicationStatus, resolveApplicationRedirect } from "./router.js";
+import { prepareRouterMatchTransfer } from "./router-binding/index.js";
+import { renderCSRDocument, renderDocumentApplication, respondApplicationResponse, runApplicationRequest } from "./server.js";
+function entry_server_createNativeServerEntry(options) {
+    return createNativeServerEntry(options, {
+        document: (document, nativeManifest, identity)=>({
+                ...document,
+                renderId: document.documentId,
+                manifest: validateSolidModuleManifest(nativeManifest, identity).modules
+            }),
+        run: (session, callback)=>runApplicationRequest(session, callback),
+        respond: respondApplicationResponse,
+        createRouter: (application, routerOptions)=>createNativeRouter(application, routerOptions, solidRouterFactory),
+        renderCSR: ({ session }, document)=>renderCSRDocument({
+                session,
+                document
+            }),
+        renderComponent: ({ session }, component, document, i18n)=>renderDocumentApplication({
+                session,
+                view: componentView(component, i18n),
+                document,
+                federation: options.federation
+            }),
+        async renderRoutes ({ context: { session }, router, outcomes, document, forbiddenValues, i18n }) {
+            await router.load();
+            prepareRouterMatchTransfer(router, session, forbiddenValues);
+            const metadata = mergeDataResponseMetadata(outcomes, {
+                status: getApplicationStatus(router)
+            });
+            const redirect = resolveApplicationRedirect(router);
+            if (redirect) return respondApplicationResponse(session, mergeDataResponseIntoResponse(redirect, metadata));
+            session.resolveResponse(dataMetadataToDocumentPolicy(metadata));
+            return renderDocumentApplication({
+                session,
+                view: routerView(router, i18n),
+                document,
+                federation: options.federation
+            });
+        }
+    });
+}
+export { entry_server_createNativeServerEntry as createNativeServerEntry };

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

@@ -0,0 +1,92 @@
+const FEDERATED_ASSET_PREFIX = "ultramodern-federation:";
+const capturedAssets = new WeakMap();
+function captureFederatedServerAssets(scope, id, assets) {
+    const instance = scope.instance;
+    if (!assets || !scope.hydrationModule || !instance?.name) return;
+    const hydration = `${scope.hydrationModule}?id=${encodeURIComponent(id)}&host=${encodeURIComponent(instance.name)}`;
+    let records = capturedAssets.get(scope);
+    if (!records) {
+        records = new Map();
+        capturedAssets.set(scope, records);
+    }
+    const baseKey = federatedAssetKey(id);
+    let key = baseKey;
+    for(let revision = 1; records.has(key); revision += 1)key = `${baseKey}:${revision}`;
+    records.set(key, {
+        hydration,
+        assets
+    });
+    return key;
+}
+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 = capturedAssets.get(scope)?.get(key);
+        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, captureFederatedServerAssets, federatedAssetKey, withFederatedAssets };

package/dist/esm-node/federation.js

@@ -0,0 +1,87 @@
+import { loadFederatedModule } from "@modern-js/renderer-core/federation";
+import { isServer } from "@solidjs/web";
+import { FederationContext } from "./federation-context.js";
+import { captureFederatedServerAssets } 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, assets } = await withTimeout(Promise.resolve().then(()=>id ? loadFederatedModule(scope.instance, id) : remote().then((module)=>({
+                        module,
+                        assets: void 0
+                    }))), 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
+            };
+            const assetKey = captureFederatedServerAssets(scope, id, assets);
+            if (!assetKey) throw new Error(`Cannot server-render ${id}: the host has no server federation state for its browser assets`);
+            return {
+                default: component,
+                $$moduleUrl: assetKey
+            };
+        });
+    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-node/i18n/I18nProvider.js

@@ -0,0 +1,42 @@
+import { I18nContext } from "./context.js";
+import * as __rspack_external_solid_js_0ac0db99 from "solid-js";
+var _m$ = Symbol();
+var _d$ = {
+    get () {
+        const props = this[_m$];
+        return props.children;
+    },
+    enumerable: true,
+    configurable: true
+};
+function _P$(_p, _p2) {
+    this[_m$] = _p;
+    this.value = _p2;
+    Object.defineProperty(this, "children", _d$);
+}
+_P$.prototype = Object.prototype;
+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 I18nContext(new _P$(props, value));
+}
+export { I18nProvider };

package/dist/esm-node/i18n/LocalizedLink.js

@@ -0,0 +1,88 @@
+import { memo, mergeProps } from "@solidjs/web";
+import { configuredLanguage, localizePath } from "@modern-js/i18n-runtime-extensions/paths";
+import { Link, useLocation, useRouter } from "../router.js";
+import { I18nContext } from "./context.js";
+import * as __rspack_external_solid_js_0ac0db99 from "solid-js";
+var _m$ = Symbol(), _m$2 = Symbol(), _m$3 = Symbol(), _m$4 = Symbol(), _m$5 = Symbol(), _m$6 = Symbol();
+var _d$ = {
+    get () {
+        const router = this[_m$];
+        const props = this[_m$2];
+        const pathname = this[_m$3];
+        return memo(()=>!!router.options.rewrite)() ? props.to : pathname();
+    },
+    enumerable: true,
+    configurable: true
+}, _d$2 = {
+    get () {
+        const router = this[_m$];
+        const externalTarget = this[_m$4];
+        const pathname = this[_m$3];
+        const props = this[_m$2];
+        return memo(()=>!!(router.options.rewrite && !externalTarget()))() ? {
+            to: pathname(),
+            inheritSearch: true,
+            hash: props.hash,
+            state: props.state
+        } : void 0;
+    },
+    enumerable: true,
+    configurable: true
+}, _d$3 = {
+    get () {
+        const targetLanguage = this[_m$5];
+        const context = this[_m$6];
+        return memo(()=>targetLanguage() === context.language())() ? void 0 : targetLanguage();
+    },
+    enumerable: true,
+    configurable: true
+}, _d$4 = {
+    get () {
+        const props = this[_m$2];
+        return props.children;
+    },
+    enumerable: true,
+    configurable: true
+};
+function _P$(_p, _p2, _p3, _p4, _p5, _p6) {
+    this[_m$] = _p;
+    this[_m$2] = _p2;
+    this[_m$3] = _p3;
+    this[_m$4] = _p4;
+    this[_m$5] = _p5;
+    this[_m$6] = _p6;
+    Object.defineProperty(this, "to", _d$);
+    Object.defineProperty(this, "mask", _d$2);
+    Object.defineProperty(this, "hreflang", _d$3);
+    Object.defineProperty(this, "children", _d$4);
+}
+_P$.prototype = Object.prototype;
+function LocalizedLink(props) {
+    const context = __rspack_external_solid_js_0ac0db99.useContext(I18nContext);
+    const router = useRouter();
+    const location = useLocation();
+    const options = __rspack_external_solid_js_0ac0db99.omit(props, "to", "language", "children");
+    const targetLanguage = ()=>void 0 === props.language ? context.language() : configuredLanguage(props.language, context.languages);
+    const externalTarget = ()=>props.to.startsWith("//") || URL.canParse(props.to);
+    const canonicalTarget = ()=>({
+            to: props.to,
+            from: props.from,
+            params: props.params,
+            unsafeRelative: props.unsafeRelative
+        });
+    const pathname = __rspack_external_solid_js_0ac0db99.createMemo(()=>{
+        if (externalTarget()) return props.to;
+        const target = router.buildLocation({
+            ...canonicalTarget(),
+            _fromLocation: location()
+        });
+        return localizePath(target.pathname, targetLanguage(), {
+            languages: [
+                ...context.languages
+            ],
+            localisedUrls: context.localisedUrls
+        });
+    });
+    return Link(mergeProps(options, new _P$(router, props, pathname, externalTarget, targetLanguage, context)));
+}
+export { LocalizedLink };

package/dist/esm-node/i18n/context.js

@@ -0,0 +1,3 @@
+import * as __rspack_external_solid_js_0ac0db99 from "solid-js";
+const I18nContext = __rspack_external_solid_js_0ac0db99.createContext();
+export { I18nContext };

package/dist/esm-node/i18n/index.js

@@ -0,0 +1,8 @@
+export { createRequestLanguageRedirect, detectRequestLanguage, languageFromPathname, resolveRequestLanguage } from "@modern-js/i18n-runtime-extensions/request-language";
+export { I18N_SSR_HANDOFF_ELEMENT_ID, createI18nSsrHandoffInlineData, readI18nSsrHandoff } from "@modern-js/i18n-runtime-extensions/ssrLanguageHandoff";
+export { createI18nUrlRewrite } from "@modern-js/i18n-runtime-extensions/urlRewrite";
+export { I18nContext } from "./context.js";
+export { I18nProvider } from "./I18nProvider.js";
+export { LocalizedLink } from "./LocalizedLink.js";
+export { createLatestLanguageSync } from "./languageSync.js";
+export { useI18n } from "./useI18n.js";

package/dist/esm-node/i18n/languageSync.js

@@ -0,0 +1,50 @@
+import { createLatestLanguageSyncBinding } from "@modern-js/i18n-runtime-extensions/language-sync/controller";
+import * as __rspack_external_solid_js_0ac0db99 from "solid-js";
+function createLatestLanguageSync(options) {
+    const binding = createLatestLanguageSyncBinding(options.policy);
+    const enabled = ()=>options.enabled?.() ?? true;
+    __rspack_external_solid_js_0ac0db99.createEffect(()=>void 0, ()=>{
+        binding.updateCallbacks({
+            changeLanguage: options.changeLanguage,
+            commitLanguage: options.commitLanguage,
+            readLanguage: options.readLanguage,
+            reportFailure: options.reportFailure
+        });
+    });
+    __rspack_external_solid_js_0ac0db99.createEffect(()=>enabled() ? options.target() : void 0, (target)=>{
+        if (!target) return;
+        binding.activate(target);
+        return ()=>binding.deactivate();
+    });
+    __rspack_external_solid_js_0ac0db99.createEffect(()=>enabled() ? [
+            options.target(),
+            options.desiredLanguage()
+        ] : [
+            void 0,
+            void 0
+        ], ([target, desiredLanguage])=>{
+        if (!target || !desiredLanguage) return void binding.clearRequest();
+        binding.request(desiredLanguage);
+    });
+    __rspack_external_solid_js_0ac0db99.createEffect(()=>enabled() && "u" > typeof window ? [
+            options.target(),
+            options.desiredLanguage()
+        ] : [
+            void 0,
+            void 0
+        ], ([target, desiredLanguage])=>{
+        if (!target || !desiredLanguage) return;
+        const retryCurrentIntent = ()=>binding.request(desiredLanguage);
+        const retryVisibleIntent = ()=>{
+            if ("visible" === document.visibilityState) retryCurrentIntent();
+        };
+        window.addEventListener("online", retryCurrentIntent);
+        document.addEventListener("visibilitychange", retryVisibleIntent);
+        return ()=>{
+            window.removeEventListener("online", retryCurrentIntent);
+            document.removeEventListener("visibilitychange", retryVisibleIntent);
+        };
+    });
+    return (language)=>binding.request(language);
+}
+export { createLatestLanguageSync };

package/dist/esm-node/i18n/types.js

@@ -0,0 +1 @@
+export { };

package/dist/esm-node/i18n/useI18n.js

@@ -0,0 +1,74 @@
+import { configuredLanguage, localizePath } from "@modern-js/i18n-runtime-extensions/paths";
+import { languageFromPathname } from "@modern-js/i18n-runtime-extensions/request-language";
+import { useRouter } from "../router.js";
+import { I18nContext } from "./context.js";
+import * as __rspack_external_solid_js_0ac0db99 from "solid-js";
+const languageSwitches = new WeakMap();
+function useI18n() {
+    const context = __rspack_external_solid_js_0ac0db99.useContext(I18nContext);
+    const { instance, languages, localisedUrls, language } = context;
+    const t = (key, options)=>{
+        language();
+        return instance.t(key, options);
+    };
+    const router = useRouter({
+        warn: false
+    });
+    const changeLanguage = (requested)=>{
+        let nextLanguage;
+        try {
+            nextLanguage = configuredLanguage(requested, languages);
+        } catch (error) {
+            return Promise.reject(error);
+        }
+        const state = languageSwitches.get(instance) ?? {
+            latest: 0,
+            queue: Promise.resolve()
+        };
+        languageSwitches.set(instance, state);
+        const generation = ++state.latest;
+        const run = state.queue.then(async ()=>{
+            if (state.latest !== generation) return;
+            const committed = instance.language;
+            const publicLanguage = ()=>router ? languageFromPathname(new URL(router.state.location.publicHref, "http://localhost").pathname, languages, router.options.basepath) : void 0;
+            const reconcile = async ()=>{
+                const language = publicLanguage() ?? committed;
+                if (instance.language !== language) await instance.changeLanguage?.(language);
+            };
+            try {
+                await instance.changeLanguage?.(nextLanguage);
+            } catch (error) {
+                await reconcile();
+                throw error;
+            }
+            if (!router) return;
+            const href = localizePath(router.state.location.href, nextLanguage, {
+                languages: [
+                    ...languages
+                ],
+                localisedUrls
+            });
+            try {
+                await router.navigate({
+                    to: ".",
+                    href,
+                    replace: true
+                });
+            } catch (error) {
+                await reconcile();
+                throw error;
+            }
+            if (publicLanguage() !== nextLanguage) await reconcile();
+        });
+        state.queue = run.catch(()=>{});
+        return run;
+    };
+    return {
+        t,
+        language,
+        languages,
+        instance,
+        changeLanguage
+    };
+}
+export { useI18n };

package/dist/esm-node/index.js

@@ -0,0 +1,58 @@
+const SOLID_RENDERER_PROFILE = {
+    renderer: "solid",
+    solid: "2.0.0-rc.15",
+    web: "2.0.0-rc.15",
+    router: "@modern-js/renderer-solid/router@3.8.3",
+    routerSource: "4fbd65c5c3b40be87a6248867c22021c1c19bba8",
+    routerCore: "1.171.38",
+    history: "1.162.5",
+    publicRouteData: {
+        containers: [
+            "plain-record",
+            "null-record",
+            "array"
+        ],
+        values: "canonical-scalars",
+        deferred: "checked-top-level-native-promises",
+        mutation: "immutable-public-snapshot",
+        unsupported: [
+            "Date",
+            "RegExp",
+            "Map",
+            "Set",
+            "AsyncIterable"
+        ]
+    },
+    publicContext: {
+        source: "managed-constructor-route-context-and-before-load",
+        providerOverrides: "unsupported"
+    },
+    nativePromiseMetadata: {
+        runtime: "2.0.0-rc.15",
+        fields: [
+            "s",
+            "v"
+        ],
+        status: [
+            0,
+            1,
+            2
+        ],
+        handle: "sealed-with-checked-metadata"
+    },
+    nativeRegistry: {
+        source: "managed-router-match-transfer",
+        rawRejectedMatchInjection: "unsupported"
+    },
+    nativeRequestContext: {
+        scope: "complete-native-request-handler",
+        event: "one-per-request-session"
+    },
+    nativeResponseHead: {
+        statusText: "fetch-response-status-text",
+        terminalOutcome: "authoritative",
+        cache: "intersect-with-session-policy"
+    },
+    dataHttpTransport: "renderer-core-rich-public-data"
+};
+export { SOLID_RENDERER_PROFILE };