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

package/dist/esm-node/router-binding/route.js

@@ -0,0 +1,162 @@
+import { mergeProps } from "@solidjs/web";
+import { BaseRootRoute, BaseRoute, BaseRouteApi, notFound } from "@tanstack/router-core";
+import { Link } from "./link.js";
+import { useLoaderData } from "./useLoaderData.js";
+import { useLoaderDeps } from "./useLoaderDeps.js";
+import { useMatch } from "./useMatch.js";
+import { useNavigate } from "./useNavigate.js";
+import { useParams } from "./useParams.js";
+import { useRouteContext } from "./useRouteContext.js";
+import { useRouter } from "./useRouter.js";
+import { useSearch } from "./useSearch.js";
+var _m$ = Symbol();
+var _d$ = {
+    get () {
+        const _self$ = this[_m$];
+        return _self$.fullPath;
+    },
+    enumerable: true,
+    configurable: true
+};
+function _P$(_p) {
+    this[_m$] = _p;
+    Object.defineProperty(this, "from", _d$);
+}
+_P$.prototype = Object.prototype;
+var _d$2 = {
+    get () {
+        const _self$2 = this[_m$];
+        return _self$2.fullPath;
+    },
+    enumerable: true,
+    configurable: true
+};
+function _P$2(_p2) {
+    this[_m$] = _p2;
+    Object.defineProperty(this, "from", _d$2);
+}
+_P$2.prototype = Object.prototype;
+function getRouteApi(id) {
+    return new RouteApi({
+        id
+    });
+}
+class RouteApi extends BaseRouteApi {
+    constructor({ id }){
+        super({
+            id
+        }), this.useMatch = (opts)=>useMatch({
+                select: opts?.select,
+                from: this.id
+            }), this.useRouteContext = (opts)=>useRouteContext({
+                ...opts,
+                from: this.id
+            }), this.useSearch = (opts)=>useSearch({
+                select: opts?.select,
+                from: this.id
+            }), this.useParams = (opts)=>useParams({
+                select: opts?.select,
+                from: this.id
+            }), this.useLoaderDeps = (opts)=>useLoaderDeps({
+                ...opts,
+                from: this.id,
+                strict: false
+            }), this.useLoaderData = (opts)=>useLoaderData({
+                ...opts,
+                from: this.id,
+                strict: false
+            }), this.useNavigate = ()=>{
+            const router = useRouter();
+            return useNavigate({
+                from: router.routesById[this.id].fullPath
+            });
+        }, this.notFound = (opts)=>notFound({
+                routeId: this.id,
+                ...opts
+            }), this.Link = (props)=>{
+            const router = useRouter();
+            const fullPath = router.routesById[this.id].fullPath;
+            return Link(mergeProps({
+                from: fullPath
+            }, props));
+        };
+    }
+}
+class Route extends BaseRoute {
+    constructor(options){
+        super(options), this.useMatch = (opts)=>useMatch({
+                select: opts?.select,
+                from: this.id
+            }), this.useRouteContext = (opts)=>useRouteContext({
+                ...opts,
+                from: this.id
+            }), this.useSearch = (opts)=>useSearch({
+                select: opts?.select,
+                from: this.id
+            }), this.useParams = (opts)=>useParams({
+                select: opts?.select,
+                from: this.id
+            }), this.useLoaderDeps = (opts)=>useLoaderDeps({
+                ...opts,
+                from: this.id
+            }), this.useLoaderData = (opts)=>useLoaderData({
+                ...opts,
+                from: this.id
+            }), this.useNavigate = ()=>useNavigate({
+                from: this.fullPath
+            }), this.Link = (props)=>{
+            const _self$ = this;
+            return Link(mergeProps(new _P$(_self$), props));
+        };
+    }
+}
+function createRoute(options) {
+    return new Route(options);
+}
+function createRootRouteWithContext() {
+    return (options)=>createRootRoute(options);
+}
+const rootRouteWithContext = createRootRouteWithContext;
+class RootRoute extends BaseRootRoute {
+    constructor(options){
+        super(options), this.useMatch = (opts)=>useMatch({
+                select: opts?.select,
+                from: this.id
+            }), this.useRouteContext = (opts)=>useRouteContext({
+                ...opts,
+                from: this.id
+            }), this.useSearch = (opts)=>useSearch({
+                select: opts?.select,
+                from: this.id
+            }), this.useParams = (opts)=>useParams({
+                select: opts?.select,
+                from: this.id
+            }), this.useLoaderDeps = (opts)=>useLoaderDeps({
+                ...opts,
+                from: this.id
+            }), this.useLoaderData = (opts)=>useLoaderData({
+                ...opts,
+                from: this.id
+            }), this.useNavigate = ()=>useNavigate({
+                from: this.fullPath
+            }), this.Link = (props)=>{
+            const _self$2 = this;
+            return Link(mergeProps(new _P$2(_self$2), props));
+        };
+    }
+}
+function createRouteMask(opts) {
+    return opts;
+}
+class NotFoundRoute extends Route {
+    constructor(options){
+        super({
+            ...options,
+            id: "404"
+        });
+    }
+}
+function createRootRoute(options) {
+    return new RootRoute(options);
+}
+export { NotFoundRoute, RootRoute, Route, RouteApi, createRootRoute, createRootRouteWithContext, createRoute, createRouteMask, getRouteApi, rootRouteWithContext };

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

@@ -0,0 +1,13 @@
+import { RouterCore } from "@tanstack/router-core";
+import { isServer } from "@tanstack/router-core/isServer";
+import { installPublicContextPublication, primeRouterFromRegistry } from "./registryTransfer.js";
+import { getStoreFactory } from "./routerStores.js";
+const createRouter = (options)=>new Router(options);
+class Router extends RouterCore {
+    constructor(options){
+        super(options, getStoreFactory);
+        installPublicContextPublication(this);
+        if (!(isServer ?? this.isServer)) primeRouterFromRegistry(this);
+    }
+}
+export { Router, createRouter };

package/dist/esm-node/router-binding/routerContext.js

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

package/dist/esm-node/router-binding/routerStores.js

@@ -0,0 +1,50 @@
+import { createNonReactiveMutableStore, createNonReactiveReadonlyStore } from "@tanstack/router-core";
+import { isServer } from "@tanstack/router-core/isServer";
+import * as __rspack_external_solid_js_0ac0db99 from "solid-js";
+const getStoreFactory = (opts)=>{
+    if (isServer ?? opts.isServer) return {
+        createMutableStore: createNonReactiveMutableStore,
+        createReadonlyStore: createNonReactiveReadonlyStore,
+        batch: (fn)=>fn()
+    };
+    let writeEpoch = 0;
+    function createSolidMutableStore(initialValue) {
+        const [signal, setSignal] = __rspack_external_solid_js_0ac0db99.createSignal(initialValue);
+        let current = initialValue;
+        let dirty = false;
+        return {
+            get: ()=>{
+                const settled = signal();
+                if (dirty && settled === current) dirty = false;
+                return dirty ? current : settled;
+            },
+            set: (next)=>{
+                current = "function" == typeof next ? next(current) : next;
+                dirty = true;
+                writeEpoch++;
+                setSignal(()=>current);
+            }
+        };
+    }
+    function createSolidReadonlyStore(read) {
+        const memo = __rspack_external_solid_js_0ac0db99.createRoot(()=>__rspack_external_solid_js_0ac0db99.createMemo(read));
+        let cache;
+        let cachedAt = -1;
+        return {
+            get: ()=>{
+                memo();
+                if (cachedAt !== writeEpoch) {
+                    cache = __rspack_external_solid_js_0ac0db99.untrack(read);
+                    cachedAt = writeEpoch;
+                }
+                return cache;
+            }
+        };
+    }
+    return {
+        createMutableStore: createSolidMutableStore,
+        createReadonlyStore: createSolidReadonlyStore,
+        batch: (fn)=>fn()
+    };
+};
+export { getStoreFactory };

package/dist/esm-node/router-binding/scroll-restoration.js

@@ -0,0 +1,12 @@
+import { getScrollRestorationScriptForRouter } from "@tanstack/router-core/scroll-restoration-script";
+import { ScriptOnce } from "./ScriptOnce.js";
+import { useRouter } from "./useRouter.js";
+function ScrollRestoration() {
+    const router = useRouter();
+    const script = getScrollRestorationScriptForRouter(router);
+    if (!script) return null;
+    return ScriptOnce({
+        children: script
+    });
+}
+export { ScrollRestoration };

package/dist/esm-node/router-binding/typePrimitives.js

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

package/dist/esm-node/router-binding/useBlocker.js

@@ -0,0 +1,152 @@
+import { memo } from "@solidjs/web";
+import { useRouter } from "./useRouter.js";
+import * as __rspack_external_solid_js_0ac0db99 from "solid-js";
+function _resolveBlockerOpts(opts, condition) {
+    if (void 0 === opts) return {
+        shouldBlockFn: ()=>true,
+        withResolver: false
+    };
+    if ("shouldBlockFn" in opts) return opts;
+    if ("function" == typeof opts) {
+        const shouldBlock = Boolean(condition ?? true);
+        const _customBlockerFn = async ()=>{
+            if (shouldBlock) return await opts();
+            return false;
+        };
+        return {
+            shouldBlockFn: _customBlockerFn,
+            enableBeforeUnload: shouldBlock,
+            withResolver: false
+        };
+    }
+    const shouldBlock = __rspack_external_solid_js_0ac0db99.createMemo(()=>Boolean(opts.condition ?? true));
+    const _customBlockerFn = async ()=>{
+        if (shouldBlock() && void 0 !== opts.blockerFn) return await opts.blockerFn();
+        return shouldBlock();
+    };
+    return {
+        get shouldBlockFn () {
+            return _customBlockerFn;
+        },
+        get enableBeforeUnload () {
+            return shouldBlock();
+        },
+        get withResolver () {
+            return void 0 === opts.blockerFn;
+        }
+    };
+}
+function useBlocker(opts, condition) {
+    const props = __rspack_external_solid_js_0ac0db99.merge({
+        enableBeforeUnload: true,
+        disabled: false,
+        withResolver: false
+    }, _resolveBlockerOpts(opts, condition));
+    const router = useRouter();
+    const [resolver, setResolver] = __rspack_external_solid_js_0ac0db99.createSignal({
+        status: "idle",
+        current: void 0,
+        next: void 0,
+        action: void 0,
+        proceed: void 0,
+        reset: void 0
+    });
+    let disposeBlock;
+    __rspack_external_solid_js_0ac0db99.createEffect(()=>props.disabled, (disabled)=>{
+        disposeBlock?.();
+        disposeBlock = void 0;
+        if (disabled) return;
+        const blockerFnComposed = async (blockerFnArgs)=>{
+            function getLocation(location) {
+                const parsedLocation = router.parseLocation(location);
+                const [, rawParams, foundRoute] = router.getMatchedRoutes(parsedLocation.pathname);
+                if (void 0 === foundRoute) return {
+                    routeId: "__notFound__",
+                    fullPath: parsedLocation.pathname,
+                    pathname: parsedLocation.pathname,
+                    params: rawParams,
+                    search: parsedLocation.search
+                };
+                return {
+                    routeId: foundRoute.id,
+                    fullPath: foundRoute.fullPath,
+                    pathname: parsedLocation.pathname,
+                    params: rawParams,
+                    search: parsedLocation.search
+                };
+            }
+            const current = getLocation(blockerFnArgs.currentLocation);
+            const next = getLocation(blockerFnArgs.nextLocation);
+            if ("__notFound__" === current.routeId && "__notFound__" !== next.routeId) return false;
+            const shouldBlock = await props.shouldBlockFn({
+                action: blockerFnArgs.action,
+                current,
+                next
+            });
+            if (!props.withResolver) return shouldBlock;
+            if (!shouldBlock) return false;
+            const promise = new Promise((resolve)=>{
+                setResolver({
+                    status: "blocked",
+                    current,
+                    next,
+                    action: blockerFnArgs.action,
+                    proceed: ()=>resolve(false),
+                    reset: ()=>resolve(true)
+                });
+            });
+            const canNavigateAsync = await promise;
+            setResolver({
+                status: "idle",
+                current: void 0,
+                next: void 0,
+                action: void 0,
+                proceed: void 0,
+                reset: void 0
+            });
+            return canNavigateAsync;
+        };
+        disposeBlock = router.history.block({
+            blockerFn: blockerFnComposed,
+            enableBeforeUnload: props.enableBeforeUnload
+        });
+    });
+    __rspack_external_solid_js_0ac0db99.onSettled(()=>()=>{
+            disposeBlock?.();
+            disposeBlock = void 0;
+        });
+    return resolver;
+}
+const _resolvePromptBlockerArgs = (props)=>{
+    if ("shouldBlockFn" in props) return props;
+    const shouldBlock = __rspack_external_solid_js_0ac0db99.createMemo(()=>Boolean(props.condition ?? true));
+    const _customBlockerFn = async ()=>{
+        if (shouldBlock() && void 0 !== props.blockerFn) return await props.blockerFn();
+        return shouldBlock;
+    };
+    return {
+        shouldBlockFn: _customBlockerFn,
+        get enableBeforeUnload () {
+            return shouldBlock();
+        },
+        get withResolver () {
+            return void 0 === props.blockerFn;
+        }
+    };
+};
+const useBlocker_Block = function(opts) {
+    const propsWithChildren = {
+        get children () {
+            return opts.children;
+        }
+    };
+    const args = _resolvePromptBlockerArgs(opts);
+    const resolver = useBlocker(args);
+    const children = __rspack_external_solid_js_0ac0db99.createMemo(()=>{
+        const child = propsWithChildren.children;
+        if (resolver && "function" == typeof child) return child(resolver());
+        return child;
+    });
+    return memo(children);
+};
+export { useBlocker, useBlocker_Block as Block };

package/dist/esm-node/router-binding/useCanGoBack.js

@@ -0,0 +1,7 @@
+import { useRouter } from "./useRouter.js";
+import * as __rspack_external_solid_js_0ac0db99 from "solid-js";
+function useCanGoBack() {
+    const router = useRouter();
+    return __rspack_external_solid_js_0ac0db99.createMemo(()=>0 !== router.stores.location.get().state.__TSR_index);
+}
+export { useCanGoBack };

package/dist/esm-node/router-binding/useLoaderData.js

@@ -0,0 +1,9 @@
+import { useMatch } from "./useMatch.js";
+function useLoaderData(opts) {
+    return useMatch({
+        from: opts.from,
+        strict: opts.strict,
+        select: (match)=>opts.select ? opts.select(match.loaderData) : match.loaderData
+    });
+}
+export { useLoaderData };

package/dist/esm-node/router-binding/useLoaderDeps.js

@@ -0,0 +1,8 @@
+import { useMatch } from "./useMatch.js";
+function useLoaderDeps(opts) {
+    return useMatch({
+        ...opts,
+        select: (match)=>opts.select ? opts.select(match.loaderDeps) : match.loaderDeps
+    });
+}
+export { useLoaderDeps };

package/dist/esm-node/router-binding/useLocation.js

@@ -0,0 +1,14 @@
+import { replaceEqualDeep } from "@tanstack/router-core";
+import { useRouter } from "./useRouter.js";
+import * as __rspack_external_solid_js_0ac0db99 from "solid-js";
+function useLocation(opts) {
+    const router = useRouter();
+    if (!opts?.select) return ()=>router.stores.location.get();
+    const select = opts.select;
+    return __rspack_external_solid_js_0ac0db99.createMemo((prev)=>{
+        const res = select(router.stores.location.get());
+        if (void 0 === prev) return res;
+        return replaceEqualDeep(prev, res);
+    });
+}
+export { useLocation };

package/dist/esm-node/router-binding/useMatch.js

@@ -0,0 +1,28 @@
+import { invariant, replaceEqualDeep } from "@tanstack/router-core";
+import { nearestMatchContext } from "./matchContext.js";
+import { useRouter } from "./useRouter.js";
+import * as __rspack_external_solid_js_0ac0db99 from "solid-js";
+function useMatch(opts) {
+    const router = useRouter();
+    const contextMatch = __rspack_external_solid_js_0ac0db99.useContext(nearestMatchContext);
+    const nearestMatch = opts.from ? void 0 : contextMatch;
+    const match = ()=>{
+        if (opts.from) return router.stores.getMatchStore(opts.from).get();
+        return nearestMatch?.[1]();
+    };
+    __rspack_external_solid_js_0ac0db99.createEffect(match, (selectedMatch)=>{
+        if (void 0 !== selectedMatch) return;
+        if (opts.shouldThrow ?? true) {
+            if ("production" !== process.env.NODE_ENV) throw new Error(`Invariant failed: Could not find ${opts.from ? `an active match from "${opts.from}"` : "a nearest match!"}`);
+            invariant();
+        }
+    });
+    return __rspack_external_solid_js_0ac0db99.createMemo((prev)=>{
+        const selectedMatch = match();
+        if (void 0 === selectedMatch) return;
+        const res = opts.select ? opts.select(selectedMatch) : selectedMatch;
+        if (void 0 === prev) return res;
+        return replaceEqualDeep(prev, res);
+    });
+}
+export { useMatch };

package/dist/esm-node/router-binding/useNavigate.js

@@ -0,0 +1,19 @@
+import { useRouter } from "./useRouter.js";
+import * as __rspack_external_solid_js_0ac0db99 from "solid-js";
+function useNavigate(_defaultOpts) {
+    const router = useRouter();
+    return (options)=>router.navigate({
+            ...options,
+            from: options.from ?? _defaultOpts?.from
+        });
+}
+function Navigate(props) {
+    const { navigate } = useRouter();
+    __rspack_external_solid_js_0ac0db99.onSettled(()=>{
+        navigate({
+            ...props
+        });
+    });
+    return null;
+}
+export { Navigate, useNavigate };

package/dist/esm-node/router-binding/useParams.js

@@ -0,0 +1,13 @@
+import { useMatch } from "./useMatch.js";
+function useParams(opts) {
+    return useMatch({
+        from: opts.from,
+        strict: opts.strict,
+        shouldThrow: opts.shouldThrow,
+        select: (match)=>{
+            const params = false === opts.strict ? match.params : match._strictParams;
+            return opts.select ? opts.select(params) : params;
+        }
+    });
+}
+export { useParams };

package/dist/esm-node/router-binding/useRouteContext.js

@@ -0,0 +1,8 @@
+import { useMatch } from "./useMatch.js";
+function useRouteContext(opts) {
+    return useMatch({
+        ...opts,
+        select: (match)=>opts.select ? opts.select(match.context) : match.context
+    });
+}
+export { useRouteContext };

package/dist/esm-node/router-binding/useRouter.js

@@ -0,0 +1,10 @@
+import { routerContext } from "./routerContext.js";
+import * as __rspack_external_solid_js_0ac0db99 from "solid-js";
+function useRouter(opts) {
+    const value = __rspack_external_solid_js_0ac0db99.useContext(routerContext);
+    if ("production" !== process.env.NODE_ENV) {
+        if ((opts?.warn ?? true) && !value) console.warn("Warning: useRouter must be used inside a <RouterProvider> component!");
+    }
+    return value;
+}
+export { useRouter };

package/dist/esm-node/router-binding/useRouterState.js

@@ -0,0 +1,19 @@
+import { replaceEqualDeep } from "@tanstack/router-core";
+import { useRouter } from "./useRouter.js";
+import * as __rspack_external_solid_js_0ac0db99 from "solid-js";
+function useRouterState(opts) {
+    const contextRouter = useRouter({
+        warn: opts?.router === void 0
+    });
+    const router = opts?.router || contextRouter;
+    if (!opts?.select) return ()=>router.stores.__store.get();
+    const select = opts.select;
+    return __rspack_external_solid_js_0ac0db99.createMemo((prev)=>{
+        const res = select(router.stores.__store.get());
+        if (void 0 === prev) return res;
+        return replaceEqualDeep(prev, res);
+    }, {
+        transparent: true
+    });
+}
+export { useRouterState };

package/dist/esm-node/router-binding/useSearch.js

@@ -0,0 +1,13 @@
+import { useMatch } from "./useMatch.js";
+function useSearch(opts) {
+    return useMatch({
+        from: opts.from,
+        strict: opts.strict,
+        shouldThrow: opts.shouldThrow,
+        select: (match)=>{
+            const search = match.search;
+            return opts.select ? opts.select(search) : search;
+        }
+    });
+}
+export { useSearch };

package/dist/esm-node/router-binding/utils.js

@@ -0,0 +1,23 @@
+import * as __rspack_external_solid_js_0ac0db99 from "solid-js";
+function useIntersectionObserver(ref, callback, disabled) {
+    const isIntersectionObserverAvailable = "function" == typeof IntersectionObserver;
+    let observerRef = null;
+    __rspack_external_solid_js_0ac0db99.createEffect(()=>[
+            ref(),
+            disabled()
+        ], ([r, isDisabled])=>{
+        if (isDisabled || !r || !isIntersectionObserverAvailable) return ()=>callback();
+        observerRef = new IntersectionObserver((entries)=>{
+            callback(entries.pop());
+        }, {
+            rootMargin: "100px"
+        });
+        observerRef.observe(r);
+        return ()=>{
+            observerRef?.disconnect();
+            callback();
+        };
+    });
+    return ()=>observerRef;
+}
+export { useIntersectionObserver };