bosia 0.6.7 → 0.6.9

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "bosia",
-	"version": "0.6.7",
+	"version": "0.6.9",
 	"type": "module",
 	"description": "A fast, batteries-included fullstack framework — SSR · Svelte 5 Runes · Bun · ElysiaJS. File-based routing inspired by SvelteKit. No Node.js, no Vite, no adapters.",
 	"keywords": [

package/src/core/client/App.svelte

@@ -1,5 +1,6 @@
 <script lang="ts">
-	import { router } from "./router.svelte.ts";
+	import { tick } from "svelte";
+	import { router, scrollToHash } from "./router.svelte.ts";
 	import { findMatch } from "../matcher.ts";
 	import { clientRoutes } from "bosia:routes";
 	import { consumePrefetch, prefetchCache, dataUrl } from "./prefetch.ts";
@@ -198,7 +199,12 @@
 					appState.errorComponent = errMod.default;
 					appState.errorProps = { error: { status: errStatus, message: errMessage } };
 					appState.errorDepth = K;
-					if (router.isPush && !router.suppressScroll) window.scrollTo(0, 0);
+					if (router.isPush && !router.suppressScroll) {
+						const hash = window.location.hash;
+						tick().then(() => {
+							if (!scrollToHash(hash)) window.scrollTo(0, 0);
+						});
+					}
 					router.suppressScroll = false;
 					settle({ url, params: match.params });
 				} catch {
@@ -290,7 +296,13 @@
 
 			// Scroll to top on forward navigation (not on popstate/back-forward).
 			// goto({ noScroll: true }) flips `router.suppressScroll` for one nav.
-			if (router.isPush && !router.suppressScroll) window.scrollTo(0, 0);
+			// If the destination URL has a hash, scroll to that element instead.
+			if (router.isPush && !router.suppressScroll) {
+				const hash = window.location.hash;
+				tick().then(() => {
+					if (!scrollToHash(hash)) window.scrollTo(0, 0);
+				});
+			}
 			router.suppressScroll = false;
 
 			// Update document title and meta description from server metadata

package/src/core/client/router.svelte.ts

@@ -16,6 +16,22 @@ function buildTarget(path: string): { url: URL; params: Record<string, string> }
 	return { url, params: match?.params ?? {} };
 }
 
+export function scrollToHash(hash: string): boolean {
+	if (typeof document === "undefined" || !hash) return false;
+	const raw = hash.startsWith("#") ? hash.slice(1) : hash;
+	if (!raw) return false;
+	let id = raw;
+	try {
+		id = decodeURIComponent(raw);
+	} catch {
+		// Fallback to raw if URI sequence is malformed.
+	}
+	const el = document.getElementById(id) ?? document.getElementById(raw);
+	if (!el) return false;
+	el.scrollIntoView();
+	return true;
+}
+
 export const router = new (class Router {
 	currentRoute = $state(
 		typeof window !== "undefined"
@@ -89,6 +105,22 @@ export const router = new (class Router {
 			if (anchor.rel.split(/\s+/).includes("external")) return;
 			if (anchor.protocol !== "https:" && anchor.protocol !== "http:") return;
 
+			// Same-page hash navigation: skip page reload, just update URL and scroll
+			// to the target element. Mirrors browser default for in-page anchors.
+			const samePage =
+				anchor.pathname === window.location.pathname &&
+				anchor.search === window.location.search;
+			if (samePage && anchor.hash) {
+				e.preventDefault();
+				const finalPath = anchor.pathname + anchor.search + anchor.hash;
+				if (this.currentRoute !== finalPath) {
+					history.pushState({}, "", finalPath);
+					this.currentRoute = finalPath;
+				}
+				scrollToHash(anchor.hash);
+				return;
+			}
+
 			e.preventDefault();
 			this.navigate(anchor.pathname + anchor.search + anchor.hash, { source: "link" });
 		});

package/src/core/server.ts

@@ -24,6 +24,7 @@ import { buildCspHeader, CSP_DIRECTIVES_TEMPLATE, CSP_ENABLED, generateNonce } f
 import { isDev, compress, isStaticPath } from "./html.ts";
 import { dev500WithPlugins } from "./dev-500.ts";
 import { OUT_DIR } from "./paths.ts";
+import { buildStaticManifest, lookupStatic } from "./staticManifest.ts";
 import { dedup, dedupKey } from "./dedup.ts";
 import {
 	CACHE_ENABLED,
@@ -170,6 +171,12 @@ function parseActionName(url: URL): string {
 	return "default";
 }
 
+// Prod: walk `dist/client`, `./public`, and `OUT_DIR` once at boot so static-asset
+// requests cost a single Map lookup instead of up to 4 `Bun.file().exists()` syscalls.
+// Dev keeps the per-request fallthrough so files dropped into `public/` mid-session
+// are served without a restart (dev's watcher doesn't fire on `public/`).
+const staticManifest = isDev ? null : buildStaticManifest(OUT_DIR);
+
 async function resolve(event: RequestEvent): Promise<Response> {
 	const { request, url, locals, cookies } = event;
 	const path = url.pathname;
@@ -327,7 +334,21 @@ async function resolve(event: RequestEvent): Promise<Response> {
 
 	// Static files
 	if (isStaticPath(path)) {
-		// dist/client: serve with cache headers based on whether filename is hashed
+		// Prod fast path: single Map lookup, no per-request stat calls.
+		if (staticManifest) {
+			const hit = lookupStatic(staticManifest, path);
+			if (hit) {
+				return new Response(
+					Bun.file(hit.absPath),
+					hit.cacheControl
+						? { headers: { "Cache-Control": hit.cacheControl } }
+						: undefined,
+				);
+			}
+			return new Response("Not Found", { status: 404 });
+		}
+		// Dev: keep the per-request fallthrough so files dropped into `public/`
+		// mid-session are served without a restart.
 		if (path.startsWith("/dist/client/")) {
 			const resolved = safePath(
 				`${OUT_DIR}/client`,
@@ -336,11 +357,7 @@ async function resolve(event: RequestEvent): Promise<Response> {
 			if (resolved) {
 				const file = Bun.file(resolved);
 				if (await file.exists()) {
-					const filename = path.split("/").pop() ?? "";
-					const isHashed = /\-[a-z0-9]{8,}\.[a-z]+$/.test(filename);
-					const cacheControl =
-						!isDev && isHashed ? "public, max-age=31536000, immutable" : "no-cache";
-					return new Response(file, { headers: { "Cache-Control": cacheControl } });
+					return new Response(file, { headers: { "Cache-Control": "no-cache" } });
 				}
 			}
 			return new Response("Not Found", { status: 404 });

package/src/core/staticManifest.ts

@@ -0,0 +1,106 @@
+import { existsSync, readdirSync, statSync } from "fs";
+import { basename, join, resolve as resolvePath } from "path";
+
+export type StaticEntry = { absPath: string; cacheControl?: string };
+export type StaticManifest = Map<string, StaticEntry>;
+
+const HASHED_BASENAME = /\-[a-z0-9]{8,}\.[a-z]+$/;
+const IMMUTABLE_CACHE = "public, max-age=31536000, immutable";
+const DEFAULT_CACHE = "no-cache";
+
+// Files/dirs at OUT_DIR root that the manifest must not surface — they're either
+// build metadata or re-merges already covered by the per-root walks.
+const OUT_DIR_SKIP_DIRS = new Set(["client", "static", "prerendered", "server"]);
+const OUT_DIR_SKIP_FILES = new Set(["manifest.json", "route-manifest.json"]);
+
+const RESERVED_PREFIX = "/__bosia/";
+
+function* walk(dir: string, rel = ""): Generator<{ abs: string; rel: string }> {
+	let entries: Array<{ name: string; isDirectory(): boolean; isFile(): boolean }>;
+	try {
+		entries = readdirSync(dir, { withFileTypes: true, encoding: "utf8" }) as unknown as Array<{
+			name: string;
+			isDirectory(): boolean;
+			isFile(): boolean;
+		}>;
+	} catch {
+		return;
+	}
+	for (const ent of entries) {
+		const childAbs = join(dir, ent.name);
+		const childRel = rel ? `${rel}/${ent.name}` : ent.name;
+		if (ent.isDirectory()) {
+			yield* walk(childAbs, childRel);
+		} else if (ent.isFile()) {
+			yield { abs: childAbs, rel: childRel };
+		}
+	}
+}
+
+function addOnce(manifest: StaticManifest, key: string, entry: StaticEntry) {
+	if (key.startsWith(RESERVED_PREFIX)) return;
+	if (manifest.has(key)) return;
+	manifest.set(key, entry);
+}
+
+export function buildStaticManifest(outDir: string): StaticManifest {
+	const manifest: StaticManifest = new Map();
+	const outAbs = resolvePath(outDir);
+
+	const clientRoot = join(outAbs, "client");
+	if (existsSync(clientRoot)) {
+		for (const { abs, rel } of walk(clientRoot)) {
+			const cacheControl = HASHED_BASENAME.test(basename(rel))
+				? IMMUTABLE_CACHE
+				: DEFAULT_CACHE;
+			addOnce(manifest, `/dist/client/${rel}`, { absPath: abs, cacheControl });
+		}
+	}
+
+	const publicRoot = resolvePath("./public");
+	if (existsSync(publicRoot)) {
+		for (const { abs, rel } of walk(publicRoot)) {
+			addOnce(manifest, `/${rel}`, { absPath: abs });
+		}
+	}
+
+	if (existsSync(outAbs)) {
+		let rootEntries: Array<{ name: string; isDirectory(): boolean; isFile(): boolean }>;
+		try {
+			rootEntries = readdirSync(outAbs, {
+				withFileTypes: true,
+				encoding: "utf8",
+			}) as unknown as Array<{ name: string; isDirectory(): boolean; isFile(): boolean }>;
+		} catch {
+			rootEntries = [];
+		}
+		for (const ent of rootEntries) {
+			if (ent.isDirectory()) {
+				if (OUT_DIR_SKIP_DIRS.has(ent.name)) continue;
+				const sub = join(outAbs, ent.name);
+				for (const { abs, rel } of walk(sub, ent.name)) {
+					addOnce(manifest, `/${rel}`, { absPath: abs });
+				}
+			} else if (ent.isFile()) {
+				if (OUT_DIR_SKIP_FILES.has(ent.name)) continue;
+				addOnce(manifest, `/${ent.name}`, { absPath: join(outAbs, ent.name) });
+			}
+		}
+	}
+
+	return manifest;
+}
+
+export function lookupStatic(manifest: StaticManifest, urlPath: string): StaticEntry | null {
+	const key = urlPath.split("?")[0];
+	return manifest.get(key) ?? null;
+}
+
+// Re-export for tests that want to confirm a file-on-disk exists at the entry.
+export function entryFileExists(entry: StaticEntry): boolean {
+	try {
+		return statSync(entry.absPath).isFile();
+	} catch {
+		return false;
+	}
+}

package/templates/default/README.md

@@ -34,8 +34,6 @@ Add pages by creating `+page.svelte` files under `src/routes/`:
 src/routes/
 └── (public)/                     # public route group — no URL segment
     ├── +page.svelte              # /
-    ├── about/
-    │   └── +page.svelte          # /about
     └── blog/
         ├── +page.svelte          # /blog
         └── [slug]/

package/templates/default/src/routes/(public)/about/+page.server.ts

@@ -1 +0,0 @@
-export const prerender = true;

package/templates/default/src/routes/(public)/about/+page.svelte

@@ -1,8 +0,0 @@
-<svelte:head>
-	<title>About | Bosia</title>
-</svelte:head>
-
-<div>
-	<h1>About</h1>
-	<p>This page is prerendered at build time — no server work per request.</p>
-</div>