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

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

@@ -0,0 +1,389 @@
+import { Dynamic, claimElement, createComponent, getNextElement, insert, mergeProps, runHydrationEvents, scope, spread, template } from "@solidjs/web";
+import { deepEqual, exactPathTest, functionalUpdate, getUrlScheme, hasKeys, isDangerousProtocol, preloadWarning, removeTrailingSlash } from "@tanstack/router-core";
+import { isServer } from "@tanstack/router-core/isServer";
+import { useHydrated } from "./ClientOnly.js";
+import { useRouter } from "./useRouter.js";
+import { useIntersectionObserver } from "./utils.js";
+import * as __rspack_external_solid_js_0ac0db99 from "solid-js";
+var _tmpl$ = /* @__PURE__ */ template("<svg><a>");
+var _tmpl$2 = /* @__PURE__ */ template("<a>");
+function mergeRefs(...refs) {
+    const setRef = (ref, el)=>{
+        if ("function" == typeof ref) ref(el);
+        else if (Array.isArray(ref)) for (const nestedRef of ref)setRef(nestedRef, el);
+    };
+    return (el)=>{
+        for (const ref of refs)setRef(ref, el);
+    };
+}
+function splitProps(props, keys) {
+    return [
+        props,
+        __rspack_external_solid_js_0ac0db99.omit(props, ...keys)
+    ];
+}
+const timeoutMap = new WeakMap();
+const cancelPreload = (eventTarget)=>{
+    clearTimeout(timeoutMap.get(eventTarget));
+    timeoutMap.delete(eventTarget);
+};
+function useLinkProps(options) {
+    const router = useRouter();
+    const shouldHydrateHash = !isServer && !!router.options.ssr;
+    const hasHydrated = useHydrated();
+    let hasRenderFetched = false;
+    const local = options;
+    const activeProps = ()=>local.activeProps ?? STATIC_ACTIVE_PROPS_GET;
+    const inactiveProps = ()=>local.inactiveProps ?? STATIC_INACTIVE_PROPS_GET;
+    const propsSafeToSpread = __rspack_external_solid_js_0ac0db99.omit(options, "activeProps", "inactiveProps", "activeOptions", "to", "preload", "preloadDelay", "preloadIntentProximity", "hashScrollIntoView", "replace", "startTransition", "resetScroll", "viewTransition", "target", "disabled", "style", "class", "onClick", "onBlur", "onFocus", "onMouseEnter", "onMouseLeave", "onMouseOver", "onMouseOut", "onTouchStart", "ignoreBlocker", "params", "search", "hash", "state", "mask", "reloadDocument", "unsafeRelative", "from");
+    const currentLocation = __rspack_external_solid_js_0ac0db99.createMemo(()=>router.stores.location.get(), {
+        equals: (prev, next)=>prev.href === next.href
+    });
+    const _options = ()=>options;
+    const next = __rspack_external_solid_js_0ac0db99.createMemo(()=>{
+        const _fromLocation = currentLocation();
+        const options = {
+            _fromLocation,
+            ..._options()
+        };
+        return __rspack_external_solid_js_0ac0db99.untrack(()=>router.buildLocation(options));
+    }, {
+        lazy: true,
+        equals: (prev, next)=>prev.href === next.href && prev.external === next.external && prev.maskedLocation?.href === next.maskedLocation?.href
+    });
+    const directExternalLink = __rspack_external_solid_js_0ac0db99.createMemo(()=>resolveExternalLink(_options().to, router.protocolAllowlist), {
+        lazy: true
+    });
+    const hrefOption = __rspack_external_solid_js_0ac0db99.createMemo(()=>{
+        if (_options().disabled) return;
+        const direct = directExternalLink();
+        if (void 0 !== direct) return direct ?? void 0;
+        return getHrefOption(next(), router);
+    }, {
+        lazy: true
+    });
+    const externalLink = __rspack_external_solid_js_0ac0db99.createMemo(()=>{
+        const direct = directExternalLink();
+        if (void 0 !== direct) return direct ?? void 0;
+        const href = hrefOption();
+        return href && getUrlScheme(href) ? href : void 0;
+    }, {
+        lazy: true
+    });
+    const linkDisabled = __rspack_external_solid_js_0ac0db99.createMemo(()=>!!local.disabled || !externalLink() && void 0 === hrefOption(), {
+        lazy: true
+    });
+    const blockedLink = ()=>linkDisabled() && !local.disabled;
+    const preload = __rspack_external_solid_js_0ac0db99.createMemo(()=>{
+        if (_options().reloadDocument || externalLink() || linkDisabled()) return false;
+        return local.preload ?? router.options.defaultPreload;
+    }, {
+        lazy: true
+    });
+    const preloadDelay = ()=>local.preloadDelay ?? router.options.defaultPreloadDelay ?? 0;
+    const isActive = __rspack_external_solid_js_0ac0db99.createMemo(()=>{
+        if (externalLink() || blockedLink()) return false;
+        const activeOptions = local.activeOptions;
+        const current = currentLocation();
+        const nextLocation = next();
+        if (activeOptions?.exact) {
+            const testExact = exactPathTest(current.pathname, nextLocation.pathname, router.basepath);
+            if (!testExact) return false;
+        } else {
+            const currentPath = removeTrailingSlash(current.pathname, router.basepath);
+            const nextPath = removeTrailingSlash(nextLocation.pathname, router.basepath);
+            const pathIsFuzzyEqual = currentPath.startsWith(nextPath) && (currentPath.length === nextPath.length || "/" === currentPath[nextPath.length]);
+            if (!pathIsFuzzyEqual) return false;
+        }
+        if (activeOptions?.includeSearch ?? true) {
+            const searchTest = deepEqual(current.search, nextLocation.search, !activeOptions?.exact, activeOptions?.explicitUndefined);
+            if (!searchTest) return false;
+        }
+        if (activeOptions?.includeHash) {
+            const currentHash = shouldHydrateHash && !hasHydrated() ? "" : current.hash;
+            return currentHash === nextLocation.hash;
+        }
+        return true;
+    }, {
+        lazy: true
+    });
+    const doPreload = ()=>router.preloadRoute({
+            ...options,
+            _builtLocation: next()
+        }).catch((err)=>{
+            console.warn(err);
+            console.warn(preloadWarning);
+        });
+    const [ref, setRefSignal] = __rspack_external_solid_js_0ac0db99.createSignal(null);
+    const setRef = (el)=>{
+        __rspack_external_solid_js_0ac0db99.runWithOwner(null, ()=>{
+            setRefSignal(el);
+        });
+    };
+    const enqueuePreload = (e)=>{
+        if (!e) return void cancelPreload(ref);
+        if (!(e.isIntersecting ?? "intent" === preload())) {
+            if (false === e.isIntersecting) cancelPreload(ref);
+            return;
+        }
+        if (!preloadDelay()) return void doPreload();
+        if (!timeoutMap.has(ref)) timeoutMap.set(ref, setTimeout(()=>{
+            timeoutMap.delete(ref);
+            doPreload();
+        }, preloadDelay()));
+    };
+    useIntersectionObserver(ref, enqueuePreload, ()=>"viewport" !== preload());
+    __rspack_external_solid_js_0ac0db99.createEffect(preload, (preloadValue)=>{
+        if (hasRenderFetched) return;
+        if ("render" === preloadValue) {
+            __rspack_external_solid_js_0ac0db99.untrack(()=>doPreload());
+            hasRenderFetched = true;
+        }
+    });
+    const handleClick = (e)=>{
+        if (externalLink() || linkDisabled()) return;
+        const element = e.currentTarget;
+        if (element.hasAttribute("download")) return;
+        const elementTarget = element.getAttribute("target");
+        const effectiveTarget = resolvedTarget() ?? elementTarget;
+        if (!isCtrlEvent(e) && !e.defaultPrevented && (!effectiveTarget || "_self" === effectiveTarget) && 0 === e.button) {
+            e.preventDefault();
+            router.navigate({
+                ...options,
+                replace: local.replace,
+                resetScroll: local.resetScroll,
+                hashScrollIntoView: local.hashScrollIntoView,
+                startTransition: local.startTransition,
+                viewTransition: local.viewTransition,
+                ignoreBlocker: local.ignoreBlocker
+            });
+        }
+    };
+    const handleTouchStart = ()=>{
+        if ("intent" !== preload()) return;
+        doPreload();
+    };
+    const handleLeave = ()=>{
+        if ("intent" === preload()) cancelPreload(ref);
+    };
+    const simpleStyling = __rspack_external_solid_js_0ac0db99.createMemo(()=>activeProps() === STATIC_ACTIVE_PROPS_GET && inactiveProps() === STATIC_INACTIVE_PROPS_GET && void 0 === local.class && void 0 === local.style, {
+        lazy: true
+    });
+    const stateHandler = (key)=>()=>resolvedStateProps()[key];
+    const handlers = (key)=>[
+            ()=>local[key],
+            stateHandler(key)
+        ];
+    const onClick = createComposedHandler(handlers("onClick"), handleClick);
+    const onBlur = createComposedHandler(handlers("onBlur"), handleLeave);
+    const onFocus = createComposedHandler(handlers("onFocus"), enqueuePreload);
+    const onMouseEnter = createComposedHandler(handlers("onMouseEnter"), enqueuePreload);
+    const onMouseOver = createComposedHandler(handlers("onMouseOver"), enqueuePreload);
+    const onMouseLeave = createComposedHandler(handlers("onMouseLeave"), handleLeave);
+    const onMouseOut = createComposedHandler(handlers("onMouseOut"), handleLeave);
+    const onTouchStart = createComposedHandler(handlers("onTouchStart"), handleTouchStart);
+    const resolvedStateProps = __rspack_external_solid_js_0ac0db99.createMemo(()=>{
+        const stateProps = externalLink() ? EMPTY_OBJECT : (isActive() ? functionalUpdate(activeProps(), {}) : functionalUpdate(inactiveProps(), {})) ?? EMPTY_OBJECT;
+        if ("production" !== process.env.NODE_ENV) warnUnknownStateKeys(stateProps, extraStateKeys);
+        return stateProps;
+    }, {
+        lazy: true
+    });
+    const resolvedTarget = ()=>{
+        const target = resolvedStateProps().target;
+        return void 0 !== target ? target : local.target;
+    };
+    const stateOrBase = (key)=>{
+        const state = resolvedStateProps()[key];
+        return void 0 !== state ? state : propsSafeToSpread[key];
+    };
+    const resolvedClass = __rspack_external_solid_js_0ac0db99.createMemo(()=>{
+        if (simpleStyling()) return isActive() ? "active" : void 0;
+        return [
+            local.class,
+            resolvedStateProps().class
+        ].filter(Boolean).join(" ") || void 0;
+    }, {
+        lazy: true
+    });
+    const resolvedStyle = __rspack_external_solid_js_0ac0db99.createMemo(()=>{
+        if (simpleStyling()) return local.style;
+        const style = {
+            ...local.style,
+            ...resolvedStateProps().style
+        };
+        return hasKeys(style) ? style : void 0;
+    }, {
+        lazy: true
+    });
+    const extraStateKeys = new Set();
+    __rspack_external_solid_js_0ac0db99.untrack(()=>{
+        for (const stateProps of [
+            functionalUpdate(activeProps(), {}),
+            functionalUpdate(inactiveProps(), {})
+        ])if (stateProps) {
+            for (const key of Object.keys(stateProps))if ("class" !== key && "style" !== key) extraStateKeys.add(key);
+        }
+    });
+    const composedRef = mergeRefs(setRef, (el)=>{
+        const r = _options().ref;
+        if ("function" == typeof r) r(el);
+    });
+    const linkProps = {};
+    for (const key of Object.keys(propsSafeToSpread))Object.defineProperty(linkProps, key, Object.getOwnPropertyDescriptor(propsSafeToSpread, key));
+    for (const key of extraStateKeys)Object.defineProperty(linkProps, key, {
+        get: ()=>resolvedStateProps()[key],
+        enumerable: true,
+        configurable: true
+    });
+    const defineGetters = (getters)=>{
+        for (const key of Object.keys(getters))Object.defineProperty(linkProps, key, {
+            get: getters[key],
+            enumerable: true,
+            configurable: true
+        });
+    };
+    for (const [key, value] of [
+        [
+            "ref",
+            composedRef
+        ],
+        [
+            "onClick",
+            onClick
+        ]
+    ])Object.defineProperty(linkProps, key, {
+        value,
+        writable: true,
+        enumerable: true,
+        configurable: true
+    });
+    const onIntent = (composed, key)=>{
+        const passthrough = createComposedHandler(handlers(key));
+        return ()=>"intent" === preload() ? composed : local[key] || stateHandler(key)() ? passthrough : void 0;
+    };
+    defineGetters({
+        onBlur: onIntent(onBlur, "onBlur"),
+        onFocus: onIntent(onFocus, "onFocus"),
+        onMouseEnter: onIntent(onMouseEnter, "onMouseEnter"),
+        onMouseOver: onIntent(onMouseOver, "onMouseOver"),
+        onMouseLeave: onIntent(onMouseLeave, "onMouseLeave"),
+        onMouseOut: onIntent(onMouseOut, "onMouseOut"),
+        onTouchStart: onIntent(onTouchStart, "onTouchStart")
+    });
+    defineGetters({
+        href: hrefOption,
+        disabled: ()=>!!local.disabled || linkDisabled(),
+        target: resolvedTarget,
+        role: ()=>linkDisabled() ? "link" : stateOrBase("role"),
+        "aria-disabled": ()=>linkDisabled() ? "true" : stateOrBase("aria-disabled"),
+        "data-status": ()=>isActive() ? "active" : stateOrBase("data-status"),
+        "aria-current": ()=>isActive() ? "page" : stateOrBase("aria-current"),
+        class: resolvedClass,
+        style: resolvedStyle
+    });
+    return linkProps;
+}
+const STATIC_ACTIVE_PROPS = {
+    class: "active"
+};
+const STATIC_ACTIVE_PROPS_GET = ()=>STATIC_ACTIVE_PROPS;
+const EMPTY_OBJECT = {};
+const STATIC_INACTIVE_PROPS_GET = ()=>EMPTY_OBJECT;
+function callHandler(event, handler) {
+    if ("function" == typeof handler) handler(event);
+    else handler[0](handler[1], event);
+    return event.defaultPrevented;
+}
+function createComposedHandler(getHandlers, fallback) {
+    return (event)=>{
+        for (const getHandler of getHandlers){
+            const handler = getHandler();
+            if (handler && callHandler(event, handler)) return;
+        }
+        fallback?.(event);
+    };
+}
+function createLink(Comp) {
+    return (props)=>createComponent(Link, mergeProps(props, {
+            _asChild: Comp
+        }));
+}
+const Link = (props)=>{
+    const [local, rest] = splitProps(props, [
+        "_asChild",
+        "children"
+    ]);
+    const [_, linkProps] = splitProps(useLinkProps(rest), [
+        "type"
+    ]);
+    const resolvedChildren = __rspack_external_solid_js_0ac0db99.children(()=>local.children);
+    const children = ()=>{
+        const ch = resolvedChildren();
+        if ("function" == typeof ch) return ch({
+            get isActive () {
+                return "active" === linkProps["data-status"];
+            }
+        });
+        return ch;
+    };
+    if ("svg" === local._asChild) {
+        const [_, svgLinkProps] = splitProps(linkProps, [
+            "class"
+        ]);
+        var _el$ = getNextElement(_tmpl$);
+        var _el$2 = _el$.firstChild;
+        claimElement(_el$2);
+        spread(_el$2, svgLinkProps, true);
+        insert(_el$2, scope(()=>children()));
+        runHydrationEvents();
+        return _el$;
+    }
+    if (!local._asChild) {
+        var _el$3 = getNextElement(_tmpl$2);
+        claimElement(_el$3);
+        spread(_el$3, linkProps, true);
+        insert(_el$3, scope(()=>children()));
+        runHydrationEvents();
+        return _el$3;
+    }
+    return createComponent(Dynamic, mergeProps({
+        get component () {
+            return local._asChild;
+        }
+    }, linkProps, {
+        get children () {
+            return children();
+        }
+    }));
+};
+function isCtrlEvent(e) {
+    return !!(e.metaKey || e.altKey || e.ctrlKey || e.shiftKey);
+}
+const warnedStateKeys = new Set();
+function warnUnknownStateKeys(stateProps, knownKeys) {
+    for (const key of Object.keys(stateProps))if (!("class" === key || "style" === key || knownKeys.has(key) || warnedStateKeys.has(key))) {
+        warnedStateKeys.add(key);
+        console.warn(`Link activeProps/inactiveProps returned "${key}" after the Link was created; return every key from the start (use undefined for "unset") so it can be applied.`);
+    }
+}
+function warnBlockedLink(href) {
+    if ("production" !== process.env.NODE_ENV) console.warn(`Blocked Link with dangerous protocol: ${href}`);
+}
+function resolveExternalLink(to, protocolAllowlist) {
+    const scheme = "string" == typeof to ? getUrlScheme(to) : void 0;
+    if (!scheme) return;
+    if (!protocolAllowlist.has(scheme)) {
+        warnBlockedLink(to);
+        return null;
+    }
+    return to;
+}
+function getHrefOption(next, router) {
+    const location = next.maskedLocation ?? next;
+    const href = location.external ? location.publicHref : router.history.createHref(location.publicHref) || "/";
+    if ((location.external || href !== location.publicHref) && isDangerousProtocol(href, router.protocolAllowlist)) return void warnBlockedLink(href);
+    return href;
+}
+const linkOptions = (options)=>options;
+export { Link, createLink, linkOptions, useLinkProps };

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

@@ -0,0 +1,7 @@
+import * as __rspack_external_solid_js_0ac0db99 from "solid-js";
+const defaultNearestMatchContext = [
+    ()=>void 0,
+    ()=>void 0
+];
+const nearestMatchContext = __rspack_external_solid_js_0ac0db99.createContext(defaultNearestMatchContext);
+export { nearestMatchContext };

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

@@ -0,0 +1,13 @@
+import { createComponent } from "@solidjs/web";
+import * as __rspack_external_solid_js_0ac0db99 from "solid-js";
+const nonRouteComponentContext = "production" !== process.env.NODE_ENV ? /* @__PURE__ */ __rspack_external_solid_js_0ac0db99.createContext(null) : void 0;
+function renderInNonRouteComponentContext(render, component) {
+    const Context = nonRouteComponentContext;
+    return createComponent(Context, {
+        value: component,
+        get children () {
+            return render();
+        }
+    });
+}
+export { nonRouteComponentContext, renderInNonRouteComponentContext };

package/dist/esm/router-binding/not-found.js

@@ -0,0 +1,35 @@
+import { createComponent, getNextElement, template } from "@solidjs/web";
+import { isNotFound } from "@tanstack/router-core";
+import { CatchBoundary } from "./CatchBoundary.js";
+import { useRouter } from "./useRouter.js";
+import * as __rspack_external_solid_js_0ac0db99 from "solid-js";
+var _tmpl$ = /* @__PURE__ */ template("<p>Not Found");
+function getNotFound(error) {
+    if (isNotFound(error)) return error;
+    if (isNotFound(error?.cause)) return error.cause;
+}
+function CatchNotFound(props) {
+    const router = useRouter();
+    const pathname = __rspack_external_solid_js_0ac0db99.createMemo(()=>router.stores.location.get().pathname);
+    const status = __rspack_external_solid_js_0ac0db99.createMemo(()=>router.stores.status.get());
+    return createComponent(CatchBoundary, {
+        getResetKey: ()=>`not-found-${pathname()}-${status()}`,
+        onCatch: (error)=>{
+            const notFoundError = getNotFound(error);
+            if (notFoundError) props.onCatch?.(notFoundError);
+            else throw error;
+        },
+        errorComponent: ({ error })=>{
+            const notFoundError = getNotFound(error);
+            if (notFoundError) return props.fallback?.(notFoundError);
+            else throw error;
+        },
+        get children () {
+            return props.children;
+        }
+    });
+}
+function DefaultGlobalNotFound() {
+    return getNextElement(_tmpl$);
+}
+export { CatchNotFound, DefaultGlobalNotFound, getNotFound };