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

package/dist/esm/route-data-error.js

@@ -0,0 +1,108 @@
+import { DataProtocolError, assertPublicData } from "@modern-js/renderer-core/data";
+import { RouteDataError } from "@modern-js/renderer-core/router";
+function invalid(message) {
+    throw new DataProtocolError(message);
+}
+function publicFields(value, required, optional = [], allowStackAccessor = false) {
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    for (const key of Reflect.ownKeys(descriptors)){
+        if ("string" != typeof key || !required.includes(key) && !optional.includes(key)) invalid("Route data errors must not contain undeclared fields");
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (descriptor.get || descriptor.set) {
+            if (allowStackAccessor && "stack" === key) continue;
+            invalid("Route data errors must not contain accessors");
+        }
+    }
+    for (const key of required)if (!Object.hasOwn(descriptors, key)) invalid("Route data errors are missing a declared field");
+    return descriptors;
+}
+function validateFields(routeId, status, name, message) {
+    if ("string" != typeof routeId || 0 === routeId.length) invalid("Route data errors require a nonempty route identifier");
+    if ("number" != typeof status || !Number.isInteger(status) || status < 200 || status > 599) invalid("Route data errors require a valid public HTTP status");
+    if ("string" != typeof name || "string" != typeof message) invalid("Route data errors require public name and message strings");
+    return {
+        routeId,
+        status,
+        name,
+        message
+    };
+}
+function projectRouteDataError(error, production = true) {
+    if (!error || "object" != typeof error || Object.getPrototypeOf(error) !== RouteDataError.prototype) invalid("Only the exact RouteDataError class has a route error projection");
+    const descriptors = publicFields(error, [
+        "routeId",
+        "status",
+        "data",
+        "name",
+        "message"
+    ], [
+        "stack"
+    ], true);
+    const routeId = descriptors.routeId.value;
+    const status = descriptors.status.value;
+    const name = descriptors.name.value;
+    const message = descriptors.message.value;
+    const fields = validateFields(routeId, status, name, message);
+    const snapshot = {
+        kind: "ultramodern-route-data-error",
+        version: 1,
+        routeId: fields.routeId,
+        status: fields.status,
+        data: descriptors.data.value,
+        error: {
+            name: fields.name,
+            message: fields.message
+        }
+    };
+    const stack = descriptors.stack;
+    if (stack && !stack.get && !stack.set) {
+        if ("string" != typeof stack.value) invalid("Route data error stacks must be strings");
+        if (!production) snapshot.error.stack = stack.value;
+    }
+    assertPublicData(snapshot);
+    return snapshot;
+}
+function plainRecord(value) {
+    if (!value || "object" != typeof value) invalid("Malformed route data error snapshot");
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && null !== prototype) invalid("Route data error snapshots require plain records");
+    return value;
+}
+function restoreRouteDataError(snapshot) {
+    const descriptors = publicFields(plainRecord(snapshot), [
+        "kind",
+        "version",
+        "routeId",
+        "status",
+        "data",
+        "error"
+    ]);
+    if ("ultramodern-route-data-error" !== descriptors.kind.value || 1 !== descriptors.version.value) invalid("Unsupported route data error snapshot");
+    const error = publicFields(plainRecord(descriptors.error.value), [
+        "name",
+        "message"
+    ], [
+        "stack"
+    ]);
+    const routeId = descriptors.routeId.value;
+    const fields = validateFields(routeId, descriptors.status.value, error.name.value, error.message.value);
+    if (error.stack && "string" != typeof error.stack.value) invalid("Route data error stacks must be strings");
+    assertPublicData(snapshot);
+    const restored = new RouteDataError(fields.routeId, {
+        kind: "error",
+        status: fields.status,
+        data: descriptors.data.value,
+        error: {
+            name: fields.name,
+            message: fields.message
+        },
+        thrown: true
+    });
+    if (error.stack) Object.defineProperty(restored, "stack", {
+        value: error.stack.value,
+        configurable: true,
+        writable: true
+    });
+    return restored;
+}
+export { projectRouteDataError, restoreRouteDataError };

package/dist/esm/router-binding/Asset.js

@@ -0,0 +1,201 @@
+import { createComponent, getNextElement, insert, ref, runHydrationEvents, scope, spread, template } from "@solidjs/web";
+import { isServer } from "@tanstack/router-core/isServer";
+import { createEffect, onCleanup, onSettled } from "solid-js";
+import { useRouter } from "./useRouter.js";
+var _tmpl$ = /* @__PURE__ */ template("<style>");
+var _tmpl$2 = /* @__PURE__ */ template("<meta>");
+var _tmpl$3 = /* @__PURE__ */ template("<link>");
+var _tmpl$4 = /* @__PURE__ */ template("<title>");
+var _tmpl$5 = /* @__PURE__ */ template("<script>");
+const INLINE_CSS_HYDRATION_ATTR = "data-tsr-inline-css";
+function Asset(asset) {
+    const { tag, attrs, children } = asset;
+    switch(tag){
+        case "title":
+            return createComponent(Title, {
+                attrs,
+                children
+            });
+        case "meta":
+            return createComponent(HeadElement, {
+                tag: "meta",
+                attrs
+            });
+        case "link":
+            return createComponent(HeadElement, {
+                tag: "link",
+                attrs
+            });
+        case "style":
+            if (asset.inlineCss && ("true" === process.env.TSS_INLINE_CSS_ENABLED || void 0 === process.env.TSS_INLINE_CSS_ENABLED && isServer)) return createComponent(InlineCssStyle, {
+                attrs,
+                children
+            });
+            return createComponent(HeadElement, {
+                tag: "style",
+                attrs,
+                children
+            });
+        case "script":
+            return createComponent(Script, {
+                attrs,
+                children
+            });
+        default:
+            return null;
+    }
+}
+function useRelocateToHead(getEl) {
+    onSettled(()=>{
+        const el = getEl();
+        if (el && el.parentNode !== document.head) document.head.appendChild(el);
+    });
+    onCleanup(()=>{
+        const el = getEl();
+        if (el?.parentNode) el.parentNode.removeChild(el);
+    });
+}
+function InlineCssStyle({ attrs, children }) {
+    const isInlineCssPlaceholder = void 0 === children;
+    const html = isInlineCssPlaceholder ? "u" < typeof document ? "" : document.querySelector(`style[${INLINE_CSS_HYDRATION_ATTR}]`)?.textContent ?? "" : children ?? "";
+    return createComponent(HeadElement, {
+        tag: "style",
+        get attrs () {
+            return {
+                ...attrs,
+                [INLINE_CSS_HYDRATION_ATTR]: ""
+            };
+        },
+        children: html
+    });
+}
+function HeadElement(props) {
+    let element;
+    switch(props.tag){
+        case "style":
+            {
+                const attrs = {
+                    ...props.attrs,
+                    innerHTML: "string" == typeof props.children ? props.children : void 0
+                };
+                element = (()=>{
+                    var _el$ = getNextElement(_tmpl$);
+                    spread(_el$, attrs, false);
+                    runHydrationEvents();
+                    return _el$;
+                })();
+                break;
+            }
+        case "meta":
+            element = (()=>{
+                var _el$2 = getNextElement(_tmpl$2);
+                spread(_el$2, ()=>props.attrs, false);
+                runHydrationEvents();
+                return _el$2;
+            })();
+            break;
+        default:
+            element = (()=>{
+                var _el$3 = getNextElement(_tmpl$3);
+                spread(_el$3, ()=>props.attrs, false);
+                runHydrationEvents();
+                return _el$3;
+            })();
+    }
+    useRelocateToHead(()=>element);
+    return element;
+}
+function Title(props) {
+    let el;
+    useRelocateToHead(()=>el);
+    createEffect(()=>props.children, (titleText)=>{
+        document.title = "string" == typeof titleText ? titleText : "";
+    });
+    var _el$4 = getNextElement(_tmpl$4);
+    spread(_el$4, ()=>props.attrs, true);
+    ref(()=>(e)=>el = e, _el$4);
+    insert(_el$4, scope(()=>props.children));
+    runHydrationEvents();
+    return _el$4;
+}
+function Script(props) {
+    const router = useRouter();
+    const attrs = props.attrs;
+    const children = props.children;
+    const dataScript = "string" == typeof attrs?.type && "" !== attrs.type && "text/javascript" !== attrs.type && "module" !== attrs.type;
+    if (isServer ?? router.isServer) {
+        if (attrs?.src) {
+            var _el$5 = getNextElement(_tmpl$5);
+            spread(_el$5, attrs, false);
+            runHydrationEvents();
+            return _el$5;
+        }
+        if ("string" == typeof children) {
+            var _el$6 = getNextElement(_tmpl$5);
+            spread(_el$6, [
+                attrs,
+                {
+                    innerHTML: children
+                }
+            ], false);
+            runHydrationEvents();
+            return _el$6;
+        }
+        return null;
+    }
+    if (dataScript && "string" == typeof children) {
+        var _el$7 = getNextElement(_tmpl$5);
+        spread(_el$7, [
+            attrs,
+            {
+                innerHTML: children
+            }
+        ], false);
+        runHydrationEvents();
+        return _el$7;
+    }
+    createEffect(()=>({
+            attrs,
+            children,
+            dataScript
+        }), ({ attrs, children, dataScript })=>{
+        if (dataScript) return;
+        let script;
+        if (attrs?.src) {
+            const normSrc = (()=>{
+                try {
+                    const base = document.baseURI || window.location.href;
+                    return new URL(attrs.src, base).href;
+                } catch  {
+                    return attrs.src;
+                }
+            })();
+            const existingScript = Array.from(document.querySelectorAll("script[src]")).find((el)=>el.src === normSrc);
+            if (existingScript) return;
+            script = document.createElement("script");
+            for (const [key, value] of Object.entries(attrs))if (void 0 !== value && false !== value) script.setAttribute(key, "boolean" == typeof value ? "" : String(value));
+            document.head.appendChild(script);
+        } else if ("string" == typeof children) {
+            const typeAttr = "string" == typeof attrs?.type ? attrs.type : "text/javascript";
+            const nonceAttr = "string" == typeof attrs?.nonce ? attrs.nonce : void 0;
+            const existingScript = Array.from(document.querySelectorAll("script:not([src])")).find((el)=>{
+                if (!(el instanceof HTMLScriptElement)) return false;
+                const sType = el.getAttribute("type") ?? "text/javascript";
+                const sNonce = el.getAttribute("nonce") ?? void 0;
+                return el.textContent === children && sType === typeAttr && sNonce === nonceAttr;
+            });
+            if (existingScript) return;
+            script = document.createElement("script");
+            script.textContent = children;
+            if (attrs) {
+                for (const [key, value] of Object.entries(attrs))if (void 0 !== value && false !== value) script.setAttribute(key, "boolean" == typeof value ? "" : String(value));
+            }
+            document.head.appendChild(script);
+        }
+        return ()=>{
+            if (script?.parentNode) script.parentNode.removeChild(script);
+        };
+    });
+    return null;
+}
+export { Asset };

package/dist/esm/router-binding/CatchBoundary.js

@@ -0,0 +1,94 @@
+import { Dynamic, createComponent, delegateEvents, getNextElement, getNextMarker, insert, memo, runHydrationEvents, scope, template } from "@solidjs/web";
+import { renderInNonRouteComponentContext } from "./nonRouteComponentContext.js";
+import * as __rspack_external_solid_js_0ac0db99 from "solid-js";
+var _tmpl$ = /* @__PURE__ */ template('<div style=padding:.5rem;max-width:100%><div style=display:flex;align-items:center;gap:.5rem><strong style=font-size:1rem>Something went wrong!</strong><button style="appearance:none;font-size:.6em;border:1px solid currentColor;padding:.1rem .2rem;font-weight:bold;border-radius:.25rem"></button></div><div style=height:.25rem></div><!$><!/>');
+var _tmpl$2 = /* @__PURE__ */ template('<div><pre style="font-size:.7em;border:1px solid red;border-radius:.25rem;padding:.3rem;color:red;overflow:auto">');
+var _tmpl$3 = /* @__PURE__ */ template("<code>");
+function CatchBoundary(props) {
+    const [retryKey, setRetryKey] = __rspack_external_solid_js_0ac0db99.createSignal({});
+    let resetBoundary;
+    let initialized = false;
+    let previousKey;
+    __rspack_external_solid_js_0ac0db99.onCleanup(()=>{
+        resetBoundary = void 0;
+    });
+    __rspack_external_solid_js_0ac0db99.createEffect(props.getResetKey, (key)=>{
+        if (!initialized) {
+            initialized = true;
+            previousKey = key;
+            return;
+        }
+        if (key === previousKey) return;
+        previousKey = key;
+        const reset = resetBoundary;
+        if (reset) queueMicrotask(()=>{
+            if (resetBoundary !== reset) return;
+            setRetryKey({});
+            reset();
+            __rspack_external_solid_js_0ac0db99.flush();
+        });
+    });
+    return createComponent(__rspack_external_solid_js_0ac0db99.Errored, {
+        fallback: (error, reset)=>{
+            const resolvedError = __rspack_external_solid_js_0ac0db99.untrack(()=>error());
+            props.onCatch?.(resolvedError);
+            resetBoundary = reset;
+            return "production" !== process.env.NODE_ENV ? renderInNonRouteComponentContext(()=>createComponent(Dynamic, {
+                    get component () {
+                        return props.errorComponent ?? ErrorComponent;
+                    },
+                    error: resolvedError,
+                    reset
+                }), "errorComponent") : createComponent(Dynamic, {
+                get component () {
+                    return props.errorComponent ?? ErrorComponent;
+                },
+                error: resolvedError,
+                reset
+            });
+        },
+        get children () {
+            return createComponent(__rspack_external_solid_js_0ac0db99.Show, {
+                get when () {
+                    return retryKey();
+                },
+                keyed: true,
+                children: (_retryKey)=>props.render?.() ?? props.children
+            });
+        }
+    });
+}
+function ErrorComponent({ error }) {
+    const [show, setShow] = __rspack_external_solid_js_0ac0db99.createSignal("production" !== process.env.NODE_ENV);
+    var _el$ = getNextElement(_tmpl$);
+    var _el$2 = _el$.firstChild;
+    var _el$3 = _el$2.firstChild;
+    var _el$4 = _el$3.nextSibling;
+    var _el$5 = _el$2.nextSibling;
+    var _el$6 = _el$5.nextSibling;
+    var [_el$7, _el$8] = getNextMarker(_el$6.nextSibling);
+    _el$4._$$click = ()=>setShow((d)=>!d);
+    insert(_el$4, ()=>show() ? "Hide Error" : "Show Error");
+    insert(_el$, scope((()=>{
+        var _c$ = memo(()=>!!show());
+        return ()=>_c$() ? (()=>{
+                var _el$9 = getNextElement(_tmpl$2);
+                var _el$10 = _el$9.firstChild;
+                insert(_el$10, scope((()=>{
+                    var _c$2 = memo(()=>!!error.message);
+                    return ()=>_c$2() ? (()=>{
+                            var _el$11 = getNextElement(_tmpl$3);
+                            insert(_el$11, scope(()=>error.message));
+                            return _el$11;
+                        })() : null;
+                })()));
+                return _el$9;
+            })() : null;
+    })()), _el$7, _el$8);
+    runHydrationEvents();
+    return _el$;
+}
+delegateEvents([
+    "click"
+]);
+export { CatchBoundary, ErrorComponent };

package/dist/esm/router-binding/ClientOnly.js

@@ -0,0 +1,26 @@
+import { createComponent } from "@solidjs/web";
+import * as __rspack_external_solid_js_0ac0db99 from "solid-js";
+function ClientOnly(props) {
+    const hydrated = useHydrated();
+    return createComponent(__rspack_external_solid_js_0ac0db99.Show, {
+        get when () {
+            return hydrated();
+        },
+        get fallback () {
+            return props.fallback ?? null;
+        },
+        get children () {
+            return props.children;
+        }
+    });
+}
+let globalHydrated = false;
+function useHydrated() {
+    const [hydrated, setHydrated] = __rspack_external_solid_js_0ac0db99.createSignal(globalHydrated && !__rspack_external_solid_js_0ac0db99.isHydrating());
+    __rspack_external_solid_js_0ac0db99.createEffect(()=>true, ()=>{
+        globalHydrated = true;
+        setHydrated(true);
+    });
+    return hydrated;
+}
+export { ClientOnly, useHydrated };

package/dist/esm/router-binding/HeadContent.js

@@ -0,0 +1,8 @@
+import { HydrationScript, createComponent, useHead } from "@solidjs/web";
+import { toHeadTags, useTags } from "./headContentUtils.js";
+function HeadContent(props) {
+    const tags = useTags(props.assetCrossOrigin);
+    useHead(()=>toHeadTags(tags()));
+    return createComponent(HydrationScript, {});
+}
+export { HeadContent };

package/dist/esm/router-binding/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Tanner Linsley
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.