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

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

@@ -0,0 +1,103 @@
+import { getLocationChangeInfo, trimPathRight } from "@tanstack/router-core";
+import { isServer } from "@tanstack/router-core/isServer";
+import { useRouter } from "./useRouter.js";
+import * as __rspack_external_solid_js_0ac0db99 from "solid-js";
+function describeNavigation(router, expected, at) {
+    if (expected.some((match)=>"pending" === match.status)) return;
+    const to = router.latestLocation;
+    const from = router.stores.resolvedLocation.get();
+    if (!from || from.href === to.href) return;
+    const leaf = expected[expected.length - 1];
+    const ref = {
+        kind: "navigation",
+        name: leaf?.fullPath || to.pathname,
+        to: to.pathname,
+        from: from.pathname
+    };
+    if (leaf && Object.keys(leaf.params).length) ref.params = leaf.params;
+    if (void 0 !== at) ref.at = at;
+    return ref;
+}
+function getResolvedLocation(router) {
+    const resolvedLocation = router.stores.resolvedLocation.get();
+    if (resolvedLocation?.href === router.latestLocation.href && resolvedLocation.state.__TSR_key === router.latestLocation.state.__TSR_key) return resolvedLocation;
+}
+function Transitioner() {
+    const router = useRouter();
+    const acks = [];
+    let committed;
+    const isCommitted = (expected)=>!!committed && committed.length === expected.length && expected.every((match, index)=>committed[index] === match);
+    let requestedAt;
+    router.startTransition = (fn, expectedMatches)=>{
+        if (isServer ?? router.isServer) {
+            fn();
+            return Promise.resolve(true);
+        }
+        return new Promise((resolve)=>{
+            const ack = [
+                expectedMatches,
+                resolve
+            ];
+            acks.push(ack);
+            let publish = fn;
+            if (void 0 !== __rspack_external_solid_js_0ac0db99.OBSERVE) {
+                const ref = describeNavigation(router, expectedMatches, requestedAt);
+                if (void 0 !== ref) {
+                    requestedAt = void 0;
+                    const observe = __rspack_external_solid_js_0ac0db99.OBSERVE;
+                    publish = ()=>observe.attribution.withOrigin(ref, fn);
+                }
+            }
+            __rspack_external_solid_js_0ac0db99.runWithOwner(null, publish);
+            try {
+                __rspack_external_solid_js_0ac0db99.flush();
+            } catch  {}
+            if (acks.includes(ack) && isCommitted(expectedMatches)) {
+                acks.splice(acks.indexOf(ack), 1);
+                resolve(true);
+            }
+        });
+    };
+    __rspack_external_solid_js_0ac0db99.createEffect(()=>router.stores.matches.get(), (current)=>{
+        committed = current;
+        if (acks.length) for (const [expected, resolve] of acks.splice(0))resolve(isCommitted(expected));
+    });
+    __rspack_external_solid_js_0ac0db99.onSettled(()=>{
+        const unsub = router.history.subscribe(()=>{
+            requestedAt ??= performance.now();
+            queueMicrotask(()=>router.load().catch(console.error));
+        });
+        router.updateLatestLocation();
+        const nextLocation = router.buildLocation({
+            to: router.latestLocation.pathname,
+            search: true,
+            params: true,
+            hash: true,
+            state: true,
+            _includeValidateSearch: true
+        });
+        if (trimPathRight(router.latestLocation.publicHref) !== trimPathRight(nextLocation.publicHref)) {
+            router.commitLocation({
+                ...nextLocation,
+                replace: true,
+                ignoreBlocker: true
+            });
+            return unsub;
+        }
+        if (!getResolvedLocation(router) && !router._tx) queueMicrotask(()=>router.load().catch(console.error));
+        return unsub;
+    });
+    return null;
+}
+function Rendered() {
+    const router = useRouter();
+    __rspack_external_solid_js_0ac0db99.onSettled(()=>{
+        const resolvedLocation = getResolvedLocation(router);
+        if (resolvedLocation) router.emit({
+            type: "onRendered",
+            ...getLocationChangeInfo(resolvedLocation, resolvedLocation)
+        });
+    });
+    return null;
+}
+export { Rendered, Transitioner };

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

@@ -0,0 +1,48 @@
+import { createComponent } from "@solidjs/web";
+import { TSR_DEFERRED_PROMISE, defer } from "@tanstack/router-core";
+import * as __rspack_external_solid_js_0ac0db99 from "solid-js";
+function track(promise) {
+    return defer(Object.isExtensible(promise) ? promise : promise.then((v)=>v));
+}
+function useAwaited({ promise: _promise }) {
+    const promise = track(_promise);
+    const data = __rspack_external_solid_js_0ac0db99.createMemo(async ()=>await promise);
+    return [
+        data(),
+        promise
+    ];
+}
+function InnerAwait(props) {
+    return createComponent(__rspack_external_solid_js_0ac0db99.Show, {
+        get when () {
+            return props.ready();
+        },
+        children: (_)=>{
+            const state = props.deferred[TSR_DEFERRED_PROMISE];
+            if ("error" === state.status) throw state.error;
+            return props.children(state.data);
+        }
+    });
+}
+function Await(props) {
+    const deferred = track(props.promise);
+    const ready = __rspack_external_solid_js_0ac0db99.createMemo(async ()=>{
+        await deferred;
+        return true;
+    });
+    const inner = createComponent(InnerAwait, {
+        deferred,
+        ready,
+        get children () {
+            return props.children;
+        }
+    });
+    if (void 0 === props.fallback) return inner;
+    return createComponent(__rspack_external_solid_js_0ac0db99.Loading, {
+        get fallback () {
+            return props.fallback;
+        },
+        children: inner
+    });
+}
+export { Await, useAwaited };

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

@@ -0,0 +1,83 @@
+import { createRoute } from "./route.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";
+function createFileRoute(_path) {
+    return (options)=>{
+        const route = createRoute(options);
+        route.isRoot = false;
+        return route;
+    };
+}
+class FileRoute {
+    constructor(path, _opts){
+        this.path = path;
+        this.createRoute = (options)=>{
+            if ("production" !== process.env.NODE_ENV) {
+                if (!this.silent) console.warn("Warning: FileRoute is deprecated and will be removed in the next major version. Use the createFileRoute(path)(options) function instead.");
+            }
+            const route = createRoute(options);
+            route.isRoot = false;
+            return route;
+        };
+        this.silent = _opts?.silent;
+    }
+}
+function FileRouteLoader(_path) {
+    if ("production" !== process.env.NODE_ENV) console.warn("Warning: FileRouteLoader is deprecated and will be removed in the next major version. Please place the loader function in the main route file, inside the `createFileRoute('/path/to/file')(options)` options");
+    return (loaderFn)=>loaderFn;
+}
+class LazyRoute {
+    constructor(opts){
+        this.useMatch = (opts)=>useMatch({
+                select: opts?.select,
+                from: this.options.id
+            });
+        this.useRouteContext = (opts)=>useRouteContext({
+                ...opts,
+                from: this.options.id
+            });
+        this.useSearch = (opts)=>useSearch({
+                select: opts?.select,
+                from: this.options.id
+            });
+        this.useParams = (opts)=>useParams({
+                select: opts?.select,
+                from: this.options.id
+            });
+        this.useLoaderDeps = (opts)=>useLoaderDeps({
+                ...opts,
+                from: this.options.id
+            });
+        this.useLoaderData = (opts)=>useLoaderData({
+                ...opts,
+                from: this.options.id
+            });
+        this.useNavigate = ()=>{
+            const router = useRouter();
+            return useNavigate({
+                from: router.routesById[this.options.id].fullPath
+            });
+        };
+        this.options = opts;
+    }
+}
+function createLazyRoute(id) {
+    return (opts)=>new LazyRoute({
+            id,
+            ...opts
+        });
+}
+function createLazyFileRoute(id) {
+    if ("object" == typeof id) return new LazyRoute(id);
+    return (opts)=>new LazyRoute({
+            id,
+            ...opts
+        });
+}
+export { FileRoute, FileRouteLoader, LazyRoute, createFileRoute, createLazyFileRoute, createLazyRoute };

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

@@ -0,0 +1,23 @@
+import { REVALIDATE_HEADER } from "@solidjs/web";
+import { REDIRECT_HEADER, decodeRedirectHeaderValue, subscribeFlightData } from "@solidjs/web/server-functions";
+function setupFlightDataConsumer(router) {
+    return subscribeFlightData((_data, { response })=>applyResponseMetadata(router, response));
+}
+function applyResponseMetadata(router, response) {
+    const carried = decodeRedirectHeaderValue(response.headers.get(REDIRECT_HEADER));
+    const declared = response.headers.get(REVALIDATE_HEADER);
+    if (!carried && null === declared) return;
+    const reload = null === declared || declared.split(",").some(Boolean);
+    const target = carried ? new URL(carried.url) : void 0;
+    const origin = router.options.origin ?? window.location.origin;
+    if (target && target.origin !== origin) return void router.navigate({
+        href: target.href,
+        replace: true
+    });
+    if (target) router.navigate({
+        href: target.pathname + target.search + target.hash,
+        replace: true
+    }).catch(console.error);
+    if (reload) router.invalidate().catch(console.error);
+}
+export { applyResponseMetadata, setupFlightDataConsumer };

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

@@ -0,0 +1,162 @@
+import { _getAssetMatches, appendUniqueUserTags, escapeHtml, getAssetCrossOrigin, getScriptPreloadAttrs, resolveManifestCssLink } from "@tanstack/router-core";
+import { isServer } from "@tanstack/router-core/isServer";
+import { useRouter } from "./useRouter.js";
+import * as __rspack_external_solid_js_0ac0db99 from "solid-js";
+const useTags = (assetCrossOrigin)=>{
+    const router = useRouter();
+    const nonce = router.options.ssr?.nonce;
+    const activeMatches = __rspack_external_solid_js_0ac0db99.createMemo(()=>_getAssetMatches(router.stores.matches.get()));
+    const routeMeta = __rspack_external_solid_js_0ac0db99.createMemo(()=>activeMatches().map((match)=>match.meta).filter((meta)=>void 0 !== meta));
+    const meta = __rspack_external_solid_js_0ac0db99.createMemo(()=>{
+        const resultMeta = [];
+        const metaByAttribute = {};
+        let title;
+        const routeMetasArray = routeMeta();
+        for(let i = routeMetasArray.length - 1; i >= 0; i--){
+            const metas = routeMetasArray[i];
+            for(let j = metas.length - 1; j >= 0; j--){
+                const m = metas[j];
+                if (m) if (m.title) {
+                    if (!title) title = {
+                        tag: "title",
+                        children: m.title
+                    };
+                } else if ("script:ld+json" in m) try {
+                    const json = JSON.stringify(m["script:ld+json"]);
+                    resultMeta.push({
+                        tag: "script",
+                        attrs: {
+                            type: "application/ld+json"
+                        },
+                        children: escapeHtml(json)
+                    });
+                } catch  {}
+                else {
+                    const attribute = m.name ?? m.property;
+                    if (attribute) {
+                        if (metaByAttribute[attribute]) continue;
+                        metaByAttribute[attribute] = true;
+                    }
+                    resultMeta.push({
+                        tag: "meta",
+                        attrs: {
+                            ...m,
+                            nonce
+                        }
+                    });
+                }
+            }
+        }
+        if (title) resultMeta.push(title);
+        if (nonce) resultMeta.push({
+            tag: "meta",
+            attrs: {
+                property: "csp-nonce",
+                content: nonce
+            }
+        });
+        resultMeta.reverse();
+        return resultMeta;
+    });
+    const links = __rspack_external_solid_js_0ac0db99.createMemo(()=>activeMatches().flatMap((match)=>match.links ?? []).filter((link)=>void 0 !== link).map((link)=>({
+                tag: "link",
+                attrs: {
+                    ...link,
+                    nonce
+                }
+            })));
+    const retainedManifestCssTags = new Map();
+    const manifestCssTags = __rspack_external_solid_js_0ac0db99.createMemo(()=>{
+        const manifest = router.ssr?.manifest;
+        const tags = [];
+        if (!manifest) return tags;
+        for (const match of activeMatches())for (const link of manifest.routes[match.routeId]?.css ?? []){
+            const resolvedLink = resolveManifestCssLink(link);
+            const tag = {
+                tag: "link",
+                attrs: {
+                    rel: "stylesheet",
+                    ...resolvedLink,
+                    crossOrigin: getAssetCrossOrigin(assetCrossOrigin, "stylesheet") ?? resolvedLink.crossOrigin,
+                    nonce
+                }
+            };
+            const key = JSON.stringify(tag);
+            if (!retainedManifestCssTags.has(key)) retainedManifestCssTags.set(key, tag);
+        }
+        tags.push(...retainedManifestCssTags.values());
+        if (manifest.inlineStyle) tags.push({
+            tag: "style",
+            attrs: {
+                ...manifest.inlineStyle.attrs,
+                nonce
+            },
+            children: manifest.inlineStyle.children,
+            inlineCss: true
+        });
+        return tags;
+    });
+    const preloadLinks = __rspack_external_solid_js_0ac0db99.createMemo(()=>{
+        const manifest = router.ssr?.manifest;
+        const tags = [];
+        for (const match of activeMatches())for (const preload of manifest?.routes[match.routeId]?.preloads ?? [])if (preload) tags.push({
+            tag: "link",
+            attrs: {
+                ...getScriptPreloadAttrs(manifest, preload, assetCrossOrigin),
+                nonce
+            }
+        });
+        return tags;
+    });
+    const styles = __rspack_external_solid_js_0ac0db99.createMemo(()=>activeMatches().flatMap((match)=>match.styles ?? []).filter((style)=>void 0 !== style).map(({ children, ...attrs })=>({
+                tag: "style",
+                attrs: {
+                    ...attrs,
+                    nonce
+                },
+                children: children
+            })));
+    const headScripts = __rspack_external_solid_js_0ac0db99.createMemo(()=>activeMatches().flatMap((match)=>match.headScripts ?? []).filter((script)=>void 0 !== script).map(({ children, ...attrs })=>({
+                tag: "script",
+                attrs: {
+                    ...attrs,
+                    nonce
+                },
+                children: children
+            })));
+    return __rspack_external_solid_js_0ac0db99.createMemo(()=>{
+        const next = [];
+        appendUniqueUserTags(next, meta());
+        appendUniqueUserTags(next, links());
+        next.push(...manifestCssTags());
+        next.push(...preloadLinks());
+        appendUniqueUserTags(next, styles());
+        appendUniqueUserTags(next, headScripts());
+        return next;
+    });
+};
+const INLINE_CSS_HYDRATION_ATTR = "data-tsr-inline-css";
+function toHeadTags(tags) {
+    return tags.map(toHeadTag);
+}
+function toHeadTag(t) {
+    const props = {
+        ...t.attrs
+    };
+    let children = t.children;
+    if ("style" === t.tag && t.inlineCss && ("true" === process.env.TSS_INLINE_CSS_ENABLED || void 0 === process.env.TSS_INLINE_CSS_ENABLED && isServer)) props[INLINE_CSS_HYDRATION_ATTR] = "";
+    if ("style" === t.tag && t.inlineCss && void 0 === children && "u" > typeof document) children = document.querySelector(`style[${INLINE_CSS_HYDRATION_ATTR}]`)?.textContent ?? "";
+    if (void 0 !== children) props.children = children;
+    const headTag = {
+        tag: t.tag,
+        props
+    };
+    if ("style" === t.tag || "script" === t.tag && void 0 === props.src) headTag.key = `tsr-${hashString(t.tag + JSON.stringify(props))}`;
+    return headTag;
+}
+function hashString(s) {
+    let h = 5381;
+    for(let i = 0; i < s.length; i++)h = (h << 5) + h + s.charCodeAt(i) | 0;
+    return (h >>> 0).toString(36);
+}
+export { toHeadTags, useTags };

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

@@ -0,0 +1,35 @@
+export * from "./history.js";
+export { createBrowserHistory, createHashHistory, createHistory, createMemoryHistory } from "@tanstack/history";
+export { DEFAULT_PROTOCOL_ALLOWLIST, SearchParamError, cleanPath, composeRewrites, createControlledPromise, createSerializationAdapter, deepEqual, defaultParseSearch, defaultStringifySearch, defer, functionalUpdate, interpolatePath, isMatch, isNotFound, isRedirect, joinPaths, lazyFn, notFound, parseSearchWith, redirect, replaceEqualDeep, resolvePath, retainSearchParams, rootRouteId, stringifySearchWith, stripSearchParams, trimPath, trimPathLeft, trimPathRight } from "@tanstack/router-core";
+export { Asset } from "./Asset.js";
+export { Await, useAwaited } from "./awaited.js";
+export { CatchBoundary, ErrorComponent } from "./CatchBoundary.js";
+export { ClientOnly, useHydrated } from "./ClientOnly.js";
+export { FileRoute, FileRouteLoader, LazyRoute, createFileRoute, createLazyFileRoute, createLazyRoute } from "./fileRoute.js";
+export { HeadContent } from "./HeadContent.js";
+export { useTags } from "./headContentUtils.js";
+export { lazyRouteComponent } from "./lazyRouteComponent.js";
+export { Link, createLink, linkOptions, useLinkProps } from "./link.js";
+export { Match, Outlet } from "./Match.js";
+export { MatchRoute, Matches, useChildMatches, useMatchRoute, useMatches, useParentMatches } from "./Matches.js";
+export { CatchNotFound, DefaultGlobalNotFound } from "./not-found.js";
+export { preparePublicContextData, preparePublicLoaderData, preparePublicMatchError } from "./publicMatchData.js";
+export { RouterContextProvider, RouterProvider } from "./RouterProvider.js";
+export { prepareRouterMatchTransfer } from "./registryTransfer.js";
+export { NotFoundRoute, RootRoute, Route, RouteApi, createRootRoute, createRootRouteWithContext, createRoute, createRouteMask, getRouteApi, rootRouteWithContext } from "./route.js";
+export { Router, createRouter } from "./router.js";
+export { ScriptOnce } from "./ScriptOnce.js";
+export { Scripts } from "./Scripts.js";
+export { ScrollRestoration, useElementScrollRestoration } from "./ScrollRestoration.js";
+export { Block, useBlocker } from "./useBlocker.js";
+export { useCanGoBack } from "./useCanGoBack.js";
+export { useLoaderData } from "./useLoaderData.js";
+export { useLoaderDeps } from "./useLoaderDeps.js";
+export { useLocation } from "./useLocation.js";
+export { useMatch } from "./useMatch.js";
+export { Navigate, useNavigate } from "./useNavigate.js";
+export { useParams } from "./useParams.js";
+export { useRouteContext } from "./useRouteContext.js";
+export { useRouter } from "./useRouter.js";
+export { useRouterState } from "./useRouterState.js";
+export { useSearch } from "./useSearch.js";

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

@@ -0,0 +1,30 @@
+import { isModuleNotFoundError } from "@tanstack/router-core";
+import { lazy } from "solid-js";
+function lazyRouteComponent(importer, exportName) {
+    const resolvedExport = exportName ?? "default";
+    let preloadPromise;
+    const comp = lazy(()=>importer().catch((error)=>{
+            if (isModuleNotFoundError(error) && error instanceof Error && "u" > typeof window && "u" > typeof sessionStorage) {
+                const storageKey = `tanstack_router_reload:${error.message}`;
+                if (!sessionStorage.getItem(storageKey)) {
+                    sessionStorage.setItem(storageKey, "1");
+                    window.location.reload();
+                    return {
+                        [resolvedExport]: ()=>null
+                    };
+                }
+            }
+            throw error;
+        }), {
+        export: resolvedExport
+    });
+    const load = comp.preload;
+    comp.preload = ()=>{
+        if (!preloadPromise) preloadPromise = load().then(()=>{}, ()=>{
+            preloadPromise = void 0;
+        });
+        return preloadPromise;
+    };
+    return comp;
+}
+export { lazyRouteComponent };