@rebask/core 0.1.5 → 0.2.0

package/dist/vite.js

@@ -78,7 +78,7 @@ async function resolveRuntimeConfigPath(root, configPath) {
     return (await findProjectFile(root, "rebask.config")) || "";
 }
 export function rebask(options = {}) {
-    const { clientTraceMetadata = [], configPath, dedupeFetch = true, deploymentId, fullHtmlForBots = false, proxyTimeout = 30_000, shellPrerenderTimeout = 30_000, } = options;
+    const { clientTraceMetadata = [], configPath, dedupeFetch = true, deploymentId, fullHtmlForBots = false, markdownUrls = true, proxyTimeout = 30_000, shellPrerenderTimeout = 30_000, } = options;
     const prerender = options.prerender ?? true;
     let resolvedConfigPath = null;
     let resolvedInstrumentationPath = null;
@@ -108,6 +108,7 @@ export function rebask(options = {}) {
         })),
         getLayoutRoutes: () => layoutRoutes,
         getRouteHandlerRoutes: () => routeHandlerRoutes,
+        hasMarkdownUrls: () => markdownUrls,
         getRscEntry: () => rscEntry,
         setDeploymentId: (deploymentId) => {
             adapterDeploymentId = deploymentId ?? null;
@@ -182,6 +183,7 @@ export function rebask(options = {}) {
                 return {
                     define: {
                         __REBASK_FULL_HTML_FOR_BOTS: JSON.stringify(fullHtmlForBots),
+                        __REBASK_MARKDOWN_URLS: JSON.stringify(markdownUrls),
                         __REBASK_DEDUPE_FETCH: JSON.stringify(dedupeFetch),
                         __REBASK_CLIENT_TRACE_HEADERS__: JSON.stringify(clientTraceMetadata),
                         __REBASK_PROXY_TIMEOUT: proxyTimeout === null ? "undefined" : JSON.stringify(proxyTimeout),
@@ -334,6 +336,17 @@ export function rebask(options = {}) {
                 const isAppFile = relativeFile.startsWith("/app/");
                 const isPageFile = isAppFile && PAGE_EXTENSIONS.some((ext) => relativeFile.endsWith(`/page.${ext}`));
                 const isLayoutFile = isAppFile && PAGE_EXTENSIONS.some((ext) => relativeFile.endsWith(`/layout.${ext}`));
+                const isMarkdownFile = isAppFile &&
+                    (relativeFile.endsWith("/markdown.md") ||
+                        PAGE_EXTENSIONS.some((ext) => relativeFile.endsWith(`/markdown.${ext}`)));
+                if (isMarkdownFile) {
+                    const moduleGraph = this.environment.moduleGraph;
+                    for (const mod of moduleGraph.getModulesByFile(file) ?? []) {
+                        moduleGraph.invalidateModule(mod);
+                    }
+                    notifyRscUpdate(server, "all");
+                    return [];
+                }
                 if (isPageFile || isLayoutFile) {
                     const scope = type === "update" && isPageFile ? resolveServerUpdateScope(modules, projectRoot) : "all";
                     notifyRscUpdate(server, scope);
@@ -363,13 +376,13 @@ export function rebask(options = {}) {
                             throw error;
                         }
                     });
-                    const { pages, layouts, routeHandlers } = await scanAppDirectory(appDir);
-                    assertNoPageRouteHandlerConflicts(pages, routeHandlers);
+                    const { pages, layouts, routeHandlers, markdownFiles } = await scanAppDirectory(appDir, markdownUrls);
+                    assertNoPageRouteHandlerConflicts(pages, routeHandlers, markdownFiles);
                     routeHandlerRoutes = buildRouteHandlerRoutes(routeHandlers);
                     // Generate page/layout routes only for the RSC environment
                     if (this.environment.name === "rsc") {
                         // Store routes in shared state (accessible via plugin API)
-                        routes = buildRoutes(layouts, pages);
+                        routes = buildRoutes(layouts, pages, markdownFiles);
                         layoutRoutes = buildLayoutRoutes(layouts);
                     }
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rebask/core",
-  "version": "0.1.5",
+  "version": "0.2.0",
   "description": "Vite plugin and runtime for React Server Components",
   "homepage": "https://github.com/lfades/vext#readme",
   "license": "MIT",
@@ -75,10 +75,6 @@
       "types": "./dist/cookies.d.ts",
       "default": "./dist/cookies.js"
     },
-    "./components/prefetch-links": {
-      "types": "./dist/components/prefetch-links.d.ts",
-      "default": "./dist/components/prefetch-links.js"
-    },
     "./components/link": {
       "types": "./dist/components/link.d.ts",
       "default": "./dist/components/link.js"

package/dist/components/prefetch-links.d.ts

@@ -1,5 +0,0 @@
-import { type PrefetchProps } from "../lib/prefetch-utils.js";
-export interface PrefetchLinksProps extends PrefetchProps {
-}
-export declare function PrefetchLinks({ prefetch }: PrefetchLinksProps): null;
-//# sourceMappingURL=prefetch-links.d.ts.map

package/dist/components/prefetch-links.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"prefetch-links.d.ts","sourceRoot":"","sources":["../../src/components/prefetch-links.tsx"],"names":[],"mappings":"AAIA,OAAO,EAKN,KAAK,aAAa,EAClB,MAAM,0BAA0B,CAAA;AAIjC,MAAM,WAAW,kBAAmB,SAAQ,aAAa;CAAG;AAI5D,wBAAgB,aAAa,CAAC,EAAE,QAAQ,EAAE,EAAE,kBAAkB,QA4H7D"}

package/dist/components/prefetch-links.js

@@ -1,174 +0,0 @@
-"use client";
-import { useAtom } from "@lfades/atom";
-import { useEffect } from "react";
-import { getNavigationLink, getPrefetchStrategy, isLinkVisible, isPrefetchable, } from "../lib/prefetch-utils.js";
-import { useOnCacheInvalidation, useRouter } from "../router.js";
-import { useRouterCache } from "./cache-slot.js";
-export function PrefetchLinks({ prefetch }) {
-    const router = useRouter();
-    // Navigation effects must not suspend link discovery during shell rendering.
-    const [pathname] = useAtom(useRouterCache().pathnameAtom);
-    const prefetchVisible = () => {
-        if (!import.meta.env.PROD)
-            return;
-        const strategy = getPrefetchStrategy(prefetch);
-        document.querySelectorAll("a").forEach((el) => {
-            // Offscreen links prefetch when they scroll back in or remount.
-            if (!(el instanceof HTMLAnchorElement) || !isPrefetchable(el) || !isLinkVisible(el)) {
-                return;
-            }
-            if (strategy === "viewport") {
-                router.prefetch(el.href, { skipShell: true }).catch(() => { });
-            }
-            else {
-                router.prefetchStatic(el.href).catch(() => { });
-            }
-        });
-    };
-    useEffect(() => {
-        function onClick(e) {
-            const link = getNavigationLink(e);
-            if (link) {
-                e.preventDefault();
-                const options = { scroll: link.dataset.scroll !== "false" };
-                if (link.href === window.location.href)
-                    router.replace(link.href, options);
-                else
-                    router.push(link.href, options);
-            }
-        }
-        document.addEventListener("click", onClick);
-        return () => {
-            document.removeEventListener("click", onClick);
-        };
-    }, [router]);
-    useEffect(() => {
-        if (!import.meta.env.PROD)
-            return;
-        const strategy = getPrefetchStrategy(prefetch);
-        const onPrefetchStatic = (el) => {
-            if (el instanceof HTMLAnchorElement && isPrefetchable(el)) {
-                router.prefetchStatic(el.href).catch(() => { });
-            }
-        };
-        const onPrefetchFull = (el) => {
-            if (el instanceof HTMLAnchorElement && isPrefetchable(el)) {
-                router.prefetch(el.href).catch(() => { });
-            }
-        };
-        if (strategy === "viewport") {
-            // A viewport full prefetch goes for the full RSC directly, never a shell.
-            return listenViewport((el) => {
-                if (el instanceof HTMLAnchorElement && isPrefetchable(el)) {
-                    router.prefetch(el.href, { skipShell: true }).catch(() => { });
-                }
-            });
-        }
-        if (strategy === "intent") {
-            // A link's static output (a full static page, or a dynamic route's shell) is always
-            // prefetched once it is in view.
-            const offViewport = listenViewport(onPrefetchStatic);
-            const offIntent = listenIntent(onPrefetchFull);
-            return () => {
-                offViewport();
-                offIntent();
-            };
-        }
-        return listenViewport(onPrefetchStatic);
-    }, [router, prefetch]);
-    // Prefetch visible links again after an invalidation
-    useOnCacheInvalidation(prefetchVisible);
-    // The persistent observer only fires on intersection changes, so links that stay in view across
-    // a navigation keep a dropped shell otherwise.
-    useEffect(prefetchVisible, [router, prefetch, pathname]);
-    // Always-on stale check on hover/focus/touch, independent of the prefetch strategy. Lets links
-    // still catch a stale segment before navigation.
-    useEffect(() => {
-        function check(target) {
-            if (!(target instanceof Element))
-                return;
-            const link = target.closest("a");
-            if (link instanceof HTMLAnchorElement && isPrefetchable(link)) {
-                router.revalidateIfStale(link.href);
-            }
-        }
-        function onMouseEnter(e) {
-            check(e.target);
-        }
-        function onFocus(e) {
-            check(e.target);
-        }
-        function onTouchStart(e) {
-            check(e.target);
-        }
-        // Capture phase so we see the events on every <a>, not just bubbling.
-        document.addEventListener("mouseenter", onMouseEnter, true);
-        document.addEventListener("focusin", onFocus, true);
-        document.addEventListener("touchstart", onTouchStart, { passive: true });
-        return () => {
-            document.removeEventListener("mouseenter", onMouseEnter, true);
-            document.removeEventListener("focusin", onFocus, true);
-            document.removeEventListener("touchstart", onTouchStart);
-        };
-    }, [router]);
-    return null;
-}
-function listenViewport(onPrefetch) {
-    const observer = new IntersectionObserver((entries) => {
-        for (const entry of entries) {
-            if (entry.isIntersecting) {
-                // Stays observed: dropped shells are prefetched again the next time the link intersects.
-                onPrefetch(entry.target);
-            }
-        }
-    }, { rootMargin: "200px" });
-    const observeLink = (link) => {
-        observer.observe(link);
-    };
-    document.querySelectorAll("a").forEach(observeLink);
-    const mutationObserver = new MutationObserver((mutations) => {
-        for (const mutation of mutations) {
-            if (mutation.type === "childList") {
-                mutation.addedNodes.forEach((node) => {
-                    if (node instanceof HTMLAnchorElement) {
-                        observeLink(node);
-                    }
-                    else if (node instanceof Element) {
-                        node.querySelectorAll("a").forEach(observeLink);
-                    }
-                });
-            }
-            if (mutation.type === "attributes" &&
-                mutation.attributeName === "href" &&
-                mutation.target instanceof HTMLAnchorElement) {
-                observer.unobserve(mutation.target);
-                observeLink(mutation.target);
-            }
-        }
-    });
-    mutationObserver.observe(document.body, {
-        childList: true,
-        subtree: true,
-        attributes: true,
-        attributeFilter: ["href"],
-    });
-    return () => {
-        observer.disconnect();
-        mutationObserver.disconnect();
-    };
-}
-function listenIntent(onPrefetch) {
-    function onMouseEnter(e) {
-        onPrefetch(e.target instanceof Element ? e.target.closest("a") : null);
-    }
-    function onFocus(e) {
-        onPrefetch(e.target);
-    }
-    // Use capture phase to catch events before they bubble
-    document.addEventListener("mouseenter", onMouseEnter, true);
-    document.addEventListener("focusin", onFocus, true);
-    return () => {
-        document.removeEventListener("mouseenter", onMouseEnter, true);
-        document.removeEventListener("focusin", onFocus, true);
-    };
-}