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

package/dist/esm-node/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;
+        };
+        if (_opts) 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-node/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-node/router-binding/headContentUtils.js

@@ -0,0 +1,168 @@
+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
+            },
+            ...void 0 !== manifest.inlineStyle.children ? {
+                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
+                },
+                ...null != children ? {
+                    children: String(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
+                },
+                ...null != children ? {
+                    children: String(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-node/router-binding/history.js

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

package/dist/esm-node/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, 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-node/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 };