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

package/dist/esm/i18n/LocalizedLink.js

@@ -0,0 +1,74 @@
+import { createComponent, memo, mergeProps } from "@solidjs/web";
+import { canonicalPath, 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";
+function LocalizedLink(props) {
+    const context = __rspack_external_solid_js_0ac0db99.useContext(I18nContext);
+    const router = useRouter();
+    const rewrite = Boolean(router.options.rewrite);
+    const targetLanguage = ()=>void 0 === props.language ? context.language() : configuredLanguage(props.language, context.languages);
+    const href = __rspack_external_solid_js_0ac0db99.createMemo(()=>localizePath(props.to, targetLanguage(), {
+            languages: [
+                ...context.languages
+            ],
+            localisedUrls: context.localisedUrls
+        }));
+    const crossLanguage = ()=>targetLanguage() !== context.language();
+    const masked = ()=>rewrite && crossLanguage();
+    const dataAttributes = Object.defineProperties({}, Object.fromEntries(Object.keys(props).filter((key)=>key.startsWith("data-")).map((key)=>[
+            key,
+            {
+                enumerable: true,
+                get: ()=>props[key]
+            }
+        ])));
+    return createComponent(Link, mergeProps(dataAttributes, {
+        get to () {
+            return memo(()=>!!masked())() ? props.to : ".";
+        },
+        get href () {
+            return memo(()=>!!masked())() ? void 0 : href();
+        },
+        get mask () {
+            return memo(()=>!!masked())() ? {
+                to: href()
+            } : void 0;
+        },
+        get hreflang () {
+            return memo(()=>!!crossLanguage())() ? targetLanguage() : void 0;
+        },
+        get class () {
+            return props.class;
+        },
+        get activeProps () {
+            return props.activeProps;
+        },
+        get inactiveProps () {
+            return props.inactiveProps;
+        },
+        get activeOptions () {
+            return props.activeOptions;
+        },
+        get replace () {
+            return props.replace;
+        },
+        get preload () {
+            return props.preload;
+        },
+        get children () {
+            return props.children;
+        }
+    }));
+}
+function useIsLocalizedActive(canonicalTarget) {
+    const context = __rspack_external_solid_js_0ac0db99.useContext(I18nContext);
+    const location = useLocation();
+    return ()=>canonicalPath(location().pathname, {
+            languages: [
+                ...context.languages
+            ],
+            localisedUrls: context.localisedUrls
+        }) === canonicalTarget;
+}
+export { LocalizedLink, useIsLocalizedActive };

package/dist/esm/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/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, useIsLocalizedActive } from "./LocalizedLink.js";
+export { createLatestLanguageSync } from "./languageSync.js";
+export { useI18n } from "./useI18n.js";

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

@@ -0,0 +1,58 @@
+const SOLID_RENDERER_PROFILE = {
+    renderer: "solid",
+    solid: "2.0.0-rc.13",
+    web: "2.0.0-rc.13",
+    router: "@modern-js/renderer-solid/router@3.8.3",
+    routerSource: "4fbd65c5c3b40be87a6248867c22021c1c19bba8",
+    routerCore: "1.171.34",
+    history: "1.162.4",
+    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.13",
+        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 };

package/dist/esm/manifest.js

@@ -0,0 +1,150 @@
+import { nativeModuleManifestFilename, readRendererIdentity } from "@modern-js/renderer-core/identity";
+const SOLID_COMPILER_VERSION = "2.0.0-rc.13";
+function solidModuleManifestFilename(entryName) {
+    return nativeModuleManifestFilename("solid", entryName);
+}
+function requireRecord(value, description) {
+    if (!value || "object" != typeof value || ![
+        Object.prototype,
+        null
+    ].includes(Object.getPrototypeOf(value))) throw new Error(`Invalid Solid module manifest ${description}`);
+    for (const key of Reflect.ownKeys(value)){
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if ("string" != typeof key || !descriptor || !("value" in descriptor)) throw new Error(`Invalid Solid module manifest ${description}: data properties are required`);
+    }
+    return value;
+}
+function requireArray(value, description) {
+    if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype) throw new Error(`Invalid Solid module manifest ${description}: an array is required`);
+    for (const key of Reflect.ownKeys(value)){
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if ("string" != typeof key || "length" !== key && !/^(0|[1-9]\d*)$/.test(key) || !descriptor || !("value" in descriptor)) throw new Error(`Invalid Solid module manifest ${description}: array data properties are required`);
+    }
+}
+function requireStrings(value, description) {
+    requireArray(value, description);
+    for(let index = 0; index < value.length; index++)if ("string" != typeof value[index] || !value[index]) throw new Error(`Invalid Solid module manifest ${description}: nonempty strings are required`);
+}
+function validateAssetUrl(base, file) {
+    const prefix = base || "/";
+    const joined = /^(?:[a-z][a-z0-9+.-]*:)?\/\//i.test(file) ? file : `${prefix.endsWith("/") ? prefix : `${prefix}/`}${file.startsWith("/") ? file.slice(1) : file}`;
+    try {
+        new URL(joined, "https://manifest.invalid/");
+    } catch (cause) {
+        throw new Error(`Invalid Solid module manifest asset URL: ${file}`, {
+            cause
+        });
+    }
+}
+function validatePreload(value, base) {
+    const link = requireRecord(value, "preload");
+    if (![
+        "fetch",
+        "font",
+        "image",
+        "script",
+        "style",
+        "track"
+    ].includes(link.as)) throw new Error("Invalid Solid module manifest preload destination");
+    if (void 0 !== link.href) {
+        if ("string" != typeof link.href || !link.href) throw new Error("Invalid Solid module manifest preload href");
+        validateAssetUrl(base, link.href);
+    }
+    if ("image" === link.as) {
+        if (void 0 !== link.imagesrcset && ("string" != typeof link.imagesrcset || !link.imagesrcset)) throw new Error("Invalid Solid module manifest image preload source set");
+        if (void 0 === link.href && void 0 === link.imagesrcset) throw new Error("Invalid Solid module manifest image preload source");
+        if (void 0 !== link.imagesizes && "string" != typeof link.imagesizes) throw new Error("Invalid Solid module manifest image preload sizes");
+    } else if (void 0 === link.href || void 0 !== link.imagesrcset || void 0 !== link.imagesizes) throw new Error("Invalid Solid module manifest preload source");
+    for (const key of [
+        "type",
+        "integrity",
+        "media"
+    ])if (void 0 !== link[key] && "string" != typeof link[key]) throw new Error(`Invalid Solid module manifest preload ${key}`);
+    const enumerated = {
+        crossorigin: [
+            "",
+            true,
+            "anonymous",
+            "use-credentials"
+        ],
+        fetchpriority: [
+            "high",
+            "low",
+            "auto"
+        ],
+        referrerpolicy: [
+            "no-referrer",
+            "no-referrer-when-downgrade",
+            "origin",
+            "origin-when-cross-origin",
+            "same-origin",
+            "strict-origin",
+            "strict-origin-when-cross-origin",
+            "unsafe-url"
+        ]
+    };
+    for (const [key, values] of Object.entries(enumerated))if (void 0 !== link[key] && !values.includes(link[key])) throw new Error(`Invalid Solid module manifest preload ${key}`);
+}
+function assertCurrentIdentity(manifest, expectedIdentity) {
+    if (!manifest.rendererIdentity || "solid" !== expectedIdentity.renderer) throw new Error("Solid module manifest requires the current Solid application build identity.");
+    try {
+        readRendererIdentity(manifest.rendererIdentity, expectedIdentity);
+    } catch (cause) {
+        throw new Error("Stale Solid module manifest identity. Serve the manifest and hydration assets from the same application build.", {
+            cause
+        });
+    }
+}
+function readSolidModuleManifest(value, expectedIdentity) {
+    const manifest = requireRecord(value, "envelope");
+    if (1 !== manifest.schemaVersion || "solid" !== manifest.renderer || manifest.compilerVersion !== SOLID_COMPILER_VERSION) throw new Error(`Solid module manifest compiler ABI mismatch. Rebuild with @solidjs/compiler ${SOLID_COMPILER_VERSION}.`);
+    assertCurrentIdentity(manifest, expectedIdentity);
+    if (!manifest.modules || "object" != typeof manifest.modules || Array.isArray(manifest.modules)) throw new Error("Solid module manifest has no module inventory. Rebuild the application.");
+    const modules = requireRecord(manifest.modules, "module inventory");
+    if (void 0 !== modules._base && "string" != typeof modules._base) throw new Error("Invalid Solid module manifest asset base");
+    const base = modules._base;
+    for (const [key, value] of Object.entries(modules)){
+        if ("_base" === key) continue;
+        const chunk = requireRecord(value, `chunk ${key}`);
+        if ("string" != typeof chunk.file || !chunk.file) throw new Error(`Invalid Solid module manifest chunk ${key}: a nonempty file is required`);
+        validateAssetUrl(base, chunk.file);
+        for (const field of [
+            "css",
+            "imports"
+        ])if (void 0 !== chunk[field]) requireStrings(chunk[field], `${key}.${field}`);
+        for (const file of chunk.css ?? [])validateAssetUrl(base, file);
+        if (void 0 !== chunk.isEntry && "boolean" != typeof chunk.isEntry) throw new Error(`Invalid Solid module manifest chunk ${key}: isEntry must be boolean`);
+        if (void 0 !== chunk.preloads) {
+            requireArray(chunk.preloads, `${key}.preloads`);
+            for (const preload of chunk.preloads)validatePreload(preload, base);
+        }
+    }
+    for (const [key, value] of Object.entries(modules))if ("_base" !== key) {
+        for (const dependency of value.imports ?? [])if ("_base" === dependency || !Object.hasOwn(modules, dependency)) throw new Error(`Solid module manifest chunk ${key} imports missing own chunk ${dependency}`);
+    }
+    return manifest;
+}
+const validatedManifests = new WeakMap();
+function validateSolidModuleManifest(value, expectedIdentity, requiredModuleKeys = []) {
+    if (!value || "object" != typeof value) throw new Error("Missing Solid module manifest. Rebuild the application before SSR or hydration.");
+    let manifest = validatedManifests.get(value);
+    if (manifest) assertCurrentIdentity(manifest, expectedIdentity);
+    else {
+        manifest = readSolidModuleManifest(value, expectedIdentity);
+        validatedManifests.set(value, manifest);
+    }
+    for (const key of requiredModuleKeys)if ("_base" === key || !Object.hasOwn(manifest.modules, key)) throw new Error(`Solid module manifest is missing ${key}. Rebuild the application before SSR or hydration.`);
+    return manifest;
+}
+const compilerArtifacts = {
+    clientManifestFile: solidModuleManifestFilename,
+    async validateClientManifest (value, identity) {
+        return {
+            nativeManifest: validateSolidModuleManifest(value, identity)
+        };
+    },
+    isMutableDevelopmentAsset (filename, entryNames) {
+        return entryNames.some((entry)=>filename === solidModuleManifestFilename(entry));
+    }
+};
+export { SOLID_COMPILER_VERSION, compilerArtifacts, solidModuleManifestFilename, validateSolidModuleManifest };

package/dist/esm/route-completion.js

@@ -0,0 +1,150 @@
+import { Dynamic, createComponent } from "@solidjs/web";
+import { DataProtocolError } from "@modern-js/renderer-core/data";
+import { createEffect, createMemo, createSignal, onCleanup } from "solid-js";
+import { createRouter, preparePublicContextData, useMatch } from "./router-binding/index.js";
+import { registerPublicRouteDataOwner } from "./router-binding/registryTransfer.js";
+const routeScopes = new WeakMap();
+const routerScopes = new WeakMap();
+function assertManagedRouteData(route) {
+    if (!route) return;
+    if (route.options.loader || route.options.beforeLoad || route.options.context) throw new DataProtocolError("Custom native Solid loader/beforeLoad/context routes are unsupported by the immutable public-data profile; use createFileSystemRouteTree");
+    for (const child of route.children ?? [])assertManagedRouteData(child);
+}
+function registerRouteCompletionScope(route, scope) {
+    routeScopes.set(route, scope);
+}
+const createApplicationRouter = (options)=>{
+    const scope = options.routeTree ? routeScopes.get(options.routeTree) : void 0;
+    if (!scope) assertManagedRouteData(options.routeTree);
+    if (scope && options.routeTree) registerPublicRouteDataOwner(options.routeTree, scope.hydrationOwner, scope.privateRoots);
+    const context = preparePublicContextData(options.context, scope?.hydrationOwner);
+    if (void 0 !== context && (!context || "object" != typeof context || Array.isArray(context))) throw new DataProtocolError("The native Solid router context must be a public record");
+    const router = createRouter({
+        ...options,
+        context
+    });
+    if (scope) {
+        scope.attach(router);
+        routerScopes.set(router, scope);
+    }
+    return router;
+};
+function ownApplicationRouteData(router) {
+    const scope = routerScopes.get(router);
+    if (scope) onCleanup(()=>scope.dispose());
+    else assertManagedRouteData(router.options.routeTree);
+}
+function createRouteCompletionScope(privateRoots = [], session) {
+    const records = new WeakMap();
+    const pending = new Set();
+    const hydration = new AbortController();
+    let router;
+    function begin(signal, cancel) {
+        if (!router) throw new Error("Use createApplicationRouter to own progressive Solid route data");
+        const [failure, setFailure] = createSignal();
+        const native = router;
+        let value;
+        let leases = 0;
+        let settled = false;
+        let failed = false;
+        const stop = ()=>{
+            if (!settled) {
+                pending.delete(stop);
+                if (value && "object" == typeof value) native.clearCache({
+                    filter: (match)=>match.loaderData === value
+                });
+                cancel();
+            }
+        };
+        const fail = (reason)=>{
+            if (failed) return;
+            failed = true;
+            settled = true;
+            pending.delete(stop);
+            if (value && "object" == typeof value) native.clearCache({
+                filter: (match)=>match.loaderData === value
+            });
+            setFailure({
+                reason
+            });
+            cancel();
+        };
+        const record = {
+            failure,
+            acquire () {
+                leases++;
+                let released = false;
+                return ()=>{
+                    if (released) return;
+                    released = true;
+                    if (0 === --leases && !native.state.matches.some((match)=>match.loaderData === value)) stop();
+                };
+            }
+        };
+        return {
+            owner: {
+                signal,
+                fail
+            },
+            publish (publicValue, completion) {
+                value = publicValue;
+                const deferred = value && "object" == typeof value ? Reflect.ownKeys(value).flatMap((key)=>{
+                    const entry = Object.getOwnPropertyDescriptor(value, key);
+                    return entry && !entry.get && entry.value instanceof Promise ? [
+                        entry.value
+                    ] : [];
+                }) : [];
+                if (!completion && 0 === deferred.length) return;
+                if (value && "object" == typeof value) {
+                    records.set(value, record);
+                    pending.add(stop);
+                } else if (completion) throw new DataProtocolError("Progressive route data requires its native value object");
+                if (completion) completion.then(()=>{
+                    settled = true;
+                    pending.delete(stop);
+                }, fail);
+                else Promise.allSettled(deferred).then(()=>{
+                    settled = true;
+                    pending.delete(stop);
+                });
+            }
+        };
+    }
+    return {
+        privateRoots,
+        hydrationOwner: session ?? {
+            signal: hydration.signal,
+            fail: (error)=>hydration.abort(error)
+        },
+        attach (native) {
+            if (router && router !== native) throw new Error("A Solid data scope already owns its native router");
+            router = native;
+        },
+        begin,
+        component (component) {
+            return function() {
+                const record = useMatch({
+                    strict: false,
+                    select: (match)=>match.loaderData && "object" == typeof match.loaderData ? records.get(match.loaderData) : void 0
+                });
+                createEffect(record, (current)=>current?.acquire());
+                const ready = createMemo(()=>{
+                    const failure = record()?.failure();
+                    if (failure) throw failure.reason;
+                    return component;
+                });
+                return createComponent(Dynamic, {
+                    get component () {
+                        return ready();
+                    }
+                });
+            };
+        },
+        dispose () {
+            hydration.abort();
+            for (const stop of pending)stop();
+            pending.clear();
+        }
+    };
+}
+export { createApplicationRouter, createRouteCompletionScope, ownApplicationRouteData, registerRouteCompletionScope };