void 0.1.6 → 0.7.0

package/dist/runtime/ws.mjs

@@ -0,0 +1,103 @@
+//#region src/runtime/ws.ts
+function defineRoom(definition) {
+	return {
+		...definition,
+		__kind: "room"
+	};
+}
+function defineWebSocket(definition) {
+	return {
+		...definition,
+		__kind: "socket"
+	};
+}
+var VoidSocket = class {
+	socket = null;
+	listeners = {
+		message: /* @__PURE__ */ new Set(),
+		open: /* @__PURE__ */ new Set(),
+		close: /* @__PURE__ */ new Set(),
+		error: /* @__PURE__ */ new Set()
+	};
+	buffer = [];
+	reconnectAttempts = 0;
+	closedByUser = false;
+	constructor(url, options) {
+		this.url = url;
+		this.options = options;
+		this.connect();
+	}
+	emit(type, value) {
+		for (const listener of this.listeners[type]) listener(value);
+	}
+	connect() {
+		const WebSocketCtor = globalThis.WebSocket;
+		if (!WebSocketCtor) throw new Error("ws: WebSocket is not available in this runtime.");
+		this.socket = new WebSocketCtor(this.url, this.options.protocols);
+		this.socket.addEventListener("open", () => {
+			this.reconnectAttempts = 0;
+			const queued = this.buffer.splice(0);
+			for (const item of queued) this.socket?.send(JSON.stringify(item));
+			this.emit("open", void 0);
+		});
+		this.socket.addEventListener("message", (event) => {
+			try {
+				this.emit("message", JSON.parse(event.data));
+			} catch (error) {
+				this.emit("error", error);
+			}
+		});
+		this.socket.addEventListener("error", (error) => {
+			this.emit("error", error);
+		});
+		this.socket.addEventListener("close", (event) => {
+			this.emit("close", {
+				code: event.code,
+				reason: event.reason,
+				wasClean: event.wasClean
+			});
+			if (this.closedByUser || this.options.reconnect === false) return;
+			if (this.options.maxReconnectAttempts != null && this.reconnectAttempts >= this.options.maxReconnectAttempts) return;
+			this.reconnectAttempts += 1;
+			const delay = this.options.reconnectDelayMs ?? 1e3;
+			setTimeout(() => this.connect(), delay);
+		});
+	}
+	send(event) {
+		if (this.socket?.readyState === 1) {
+			this.socket.send(JSON.stringify(event));
+			return;
+		}
+		this.buffer.push(event);
+	}
+	close(code, reason) {
+		this.closedByUser = true;
+		this.socket?.close(code, reason);
+	}
+	on(type, handler) {
+		this.listeners[type].add(handler);
+		return () => {
+			this.listeners[type].delete(handler);
+		};
+	}
+};
+function resolveBaseUrl(baseURL) {
+	if (baseURL) return new URL(baseURL);
+	const location = globalThis.location;
+	if (!location) throw new Error("ws: connect() requires a browser-like runtime or an explicit \"baseURL\".");
+	return new URL(location.href);
+}
+function interpolateParams(path, params) {
+	let resolved = path;
+	if (params) for (const [key, value] of Object.entries(params)) resolved = resolved.replace(`:${key}`, encodeURIComponent(value));
+	return resolved;
+}
+function connect(path, options = {}) {
+	const base = resolveBaseUrl(options.baseURL);
+	const resolvedPath = interpolateParams(path, options.params);
+	const url = new URL(resolvedPath, base);
+	url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+	return new VoidSocket(url.toString(), options);
+}
+//#endregion
+export { VoidSocket, connect, defineRoom, defineWebSocket };

package/dist/scan-Ba4hFwlH.mjs

@@ -0,0 +1,324 @@
+import { a as join, n as dirname, r as extname, t as basename } from "./pathe.M-eThtNZ-D-kmWkCS.mjs";
+import { t as glob } from "./dist-DUyXJLkq.mjs";
+import { existsSync, readFileSync } from "node:fs";
+//#region src/router/parse-filename.ts
+const EXTENSIONS = [
+	".ts",
+	".mts",
+	".js",
+	".mjs"
+];
+const ENV_SUFFIXES = ["dev", "prod"];
+function parsePath(relativePath, isWebSocketRoute) {
+	const filePath = relativePath;
+	let path = relativePath.replace(/\\/g, "/");
+	for (const ext of EXTENSIONS) if (path.endsWith(ext)) {
+		path = path.slice(0, -ext.length);
+		break;
+	}
+	if (isWebSocketRoute && path.endsWith(".ws")) path = path.slice(0, -3);
+	const segments = path.split("/");
+	let filename = segments.pop();
+	let env = null;
+	for (const suffix of ENV_SUFFIXES) if (filename.endsWith(`.${suffix}`)) {
+		env = suffix;
+		filename = filename.slice(0, -(suffix.length + 1));
+		break;
+	}
+	segments.push(filename);
+	if (segments[segments.length - 1] === "index") segments.pop();
+	const filtered = segments.filter((s) => !s.startsWith("(") || !s.endsWith(")"));
+	const params = [];
+	let catchAll = false;
+	return {
+		pattern: "/" + filtered.map((segment) => {
+			if (segment.startsWith("[...") && segment.endsWith("]")) {
+				const paramName = segment.slice(4, -1);
+				catchAll = true;
+				if (paramName) {
+					params.push(paramName);
+					return `:${paramName}{.+}`;
+				}
+				return "*";
+			}
+			if (segment.startsWith("[") && segment.endsWith("]")) {
+				const paramName = segment.slice(1, -1);
+				params.push(paramName);
+				return `:${paramName}`;
+			}
+			return segment;
+		}).join("/"),
+		methods: [],
+		params,
+		catchAll,
+		env,
+		filePath
+	};
+}
+/**
+* Parse a route filename (relative to routes/) into a RouteDefinition.
+*
+* Rules (applied in order):
+* 1. Strip file extension (.ts, .js, .mts, .mjs)
+* 2. Check for env suffix (.dev, .prod) → strip and record
+* 3. Strip trailing "index" segment
+* 4. Remove route group directories: (groupname)
+* 5. Convert [param] → :param, [...param] → :param{.+}, [...] → *
+* 6. Prefix with /
+*/
+function parseRouteFilename(relativePath) {
+	return parsePath(relativePath, false);
+}
+/** Parse a `.ws.*` route filename into a regular route definition. */
+function parseWebSocketFilename(relativePath) {
+	return parsePath(relativePath, true);
+}
+//#endregion
+//#region src/pages/layout-resolution.ts
+function isNamedLayout(layout) {
+	return "name" in layout;
+}
+function toLayoutId(layout) {
+	if (isNamedLayout(layout)) return layout.directory ? `${layout.directory}/_layouts/${layout.name}` : `_layouts/${layout.name}`;
+	return layout.directory ? `${layout.directory}/layout` : "layout";
+}
+/** Resolve the layout chain for a component (innermost last) */
+function resolveLayoutChain(componentId, layouts) {
+	const parts = componentId.split("/");
+	const chain = [];
+	const root = layouts.find((l) => l.directory === "");
+	if (root) chain.push(root);
+	let dir = "";
+	for (let i = 0; i < parts.length - 1; i++) {
+		dir = dir ? `${dir}/${parts[i]}` : parts[i];
+		const layout = layouts.find((l) => l.directory === dir);
+		if (layout) chain.push(layout);
+	}
+	return chain;
+}
+/** Walk up directory tree to find closest _layouts/<name> */
+function resolveNamedLayout(name, componentId, namedLayouts) {
+	const parts = componentId.split("/");
+	const dirs = [];
+	let dir = "";
+	for (let i = 0; i < parts.length - 1; i++) {
+		dir = dir ? `${dir}/${parts[i]}` : parts[i];
+		dirs.push(dir);
+	}
+	dirs.reverse();
+	dirs.push("");
+	for (const d of dirs) {
+		const found = namedLayouts.find((nl) => nl.name === name && nl.directory === d);
+		if (found) return found;
+	}
+	return null;
+}
+function resolveEffectiveLayoutEntries(page, layouts, namedLayouts) {
+	if (page.layout === false) return [];
+	const defaultChain = resolveLayoutChain(page.componentId, layouts).map((layout) => ({
+		id: toLayoutId(layout),
+		definition: layout
+	}));
+	if (page.layout === void 0) return defaultChain;
+	const isExclusive = page.layout.startsWith("!");
+	const name = isExclusive ? page.layout.slice(1) : page.layout;
+	if (name.startsWith(".") || name.startsWith("/")) return defaultChain;
+	const resolved = resolveNamedLayout(name, page.componentId, namedLayouts);
+	if (!resolved) return defaultChain;
+	const namedEntry = {
+		id: toLayoutId(resolved),
+		definition: resolved
+	};
+	if (isExclusive) return [namedEntry];
+	if (defaultChain.length === 0) return [namedEntry];
+	const chain = [...defaultChain];
+	chain[chain.length - 1] = namedEntry;
+	return chain;
+}
+/** Resolve effective layout chain accounting for named layout selection */
+function resolveEffectiveLayoutChain(page, layouts, namedLayouts) {
+	return resolveEffectiveLayoutEntries(page, layouts, namedLayouts).map((layout) => layout.definition);
+}
+function resolveLayoutIds(page, layouts, namedLayouts) {
+	return resolveEffectiveLayoutEntries(page, layouts, namedLayouts).map((layout) => layout.id);
+}
+//#endregion
+//#region src/pages/scan.ts
+const COMPONENT_EXTENSIONS = [
+	"vue",
+	"tsx",
+	"jsx",
+	"svelte",
+	"md"
+];
+const SERVER_EXTENSIONS = [
+	"ts",
+	"tsx",
+	"js",
+	"mjs",
+	"mts"
+];
+const PAGES_EXPORT_RE = /export\s+(?:const|function|async\s+function)\s+(loader|actions?)\b/g;
+const REVALIDATE_RE = /export\s+const\s+revalidate\s*=\s*(\d+)\s*;/;
+const PRERENDER_RE = /export\s+const\s+prerender\s*=\s*true\s*;/;
+const PRERENDER_FALSE_RE = /export\s+const\s+prerender\s*=\s*false\s*;/;
+const GET_PRERENDER_PATHS_RE = /export\s+(?:async\s+)?function\s+getPrerenderPaths\b/;
+const LAYOUT_STRING_RE = /export\s+const\s+layout\s*=\s*["']([^"']+)["']\s*;?/;
+const LAYOUT_FALSE_RE = /export\s+const\s+layout\s*=\s*false\s*;?/;
+const MAX_REVALIDATE = 31536e3;
+async function scanPages(root, options) {
+	const pagesDir = join(root, "pages");
+	if (!existsSync(pagesDir)) return {
+		pages: [],
+		layouts: [],
+		namedLayouts: []
+	};
+	const files = await glob(`**/*.{${COMPONENT_EXTENSIONS.join(",")}}`, {
+		cwd: pagesDir,
+		absolute: false
+	});
+	const pages = [];
+	const layouts = [];
+	const namedLayouts = [];
+	for (const file of files) {
+		const segments = file.split("/");
+		if (segments.some((s) => s.startsWith("_") && s !== "_layouts")) continue;
+		const ext = extname(file);
+		let base = basename(file, ext);
+		let island;
+		let hasIslandSuffix = false;
+		if (base.endsWith(".island")) {
+			island = true;
+			hasIslandSuffix = true;
+			base = base.slice(0, -7);
+		}
+		if (ext === ".md") island = true;
+		const layoutsDirIdx = segments.indexOf("_layouts");
+		if (layoutsDirIdx !== -1) {
+			if (layoutsDirIdx === segments.length - 2) namedLayouts.push({
+				name: base,
+				directory: segments.slice(0, layoutsDirIdx).join("/") || "",
+				filePath: file,
+				island
+			});
+			continue;
+		}
+		if (base === "layout") {
+			const dir = dirname(file);
+			layouts.push({
+				directory: dir === "." ? "" : dir,
+				filePath: file,
+				island
+			});
+			continue;
+		}
+		const route = parseRouteFilename(hasIslandSuffix ? file.replace(`.island${ext}`, ".ts") : file.replace(ext, ".ts"));
+		const componentId = file.replace(ext, "").replace(/\.island$/, "").replace(/\/index$/, "").replace(/^index$/, "") || "index";
+		let serverPath = null;
+		const methods = [];
+		let revalidate;
+		let prerender;
+		let prerenderExplicitlyFalse = false;
+		let hasGetPrerenderPaths;
+		const serverBase = hasIslandSuffix ? file.replace(`.island${ext}`, "") : file.replace(ext, "");
+		for (const serverExt of SERVER_EXTENSIONS) {
+			const candidate = `${serverBase}.server.${serverExt}`;
+			if (existsSync(join(pagesDir, candidate))) {
+				serverPath = candidate;
+				const content = readFileSync(join(pagesDir, candidate), "utf-8");
+				for (const m of content.matchAll(PAGES_EXPORT_RE)) methods.push(m[1]);
+				const revalidateMatch = content.match(REVALIDATE_RE);
+				if (revalidateMatch) revalidate = Number(revalidateMatch[1]);
+				if (PRERENDER_RE.test(content)) prerender = true;
+				if (PRERENDER_FALSE_RE.test(content)) prerenderExplicitlyFalse = true;
+				if (GET_PRERENDER_PATHS_RE.test(content)) hasGetPrerenderPaths = true;
+				break;
+			}
+		}
+		if (options?.output === "static") {
+			if (!prerenderExplicitlyFalse && prerender !== true) {
+				if (!(route.params.length > 0 || route.catchAll) || hasGetPrerenderPaths) prerender = true;
+			}
+		} else if (island && !methods.includes("loader") && route.params.length === 0 && !route.catchAll && !prerenderExplicitlyFalse) prerender = true;
+		if (prerender && revalidate === void 0) revalidate = MAX_REVALIDATE;
+		let metadata;
+		let layout;
+		if (ext === ".md") {
+			const mdContent = readFileSync(join(pagesDir, file), "utf-8");
+			metadata = extractFrontmatterMeta(mdContent);
+			layout = extractFrontmatterLayout(mdContent);
+		} else {
+			const componentContent = readFileSync(join(pagesDir, file), "utf-8");
+			const layoutStringMatch = componentContent.match(LAYOUT_STRING_RE);
+			if (layoutStringMatch) layout = layoutStringMatch[1];
+			else if (LAYOUT_FALSE_RE.test(componentContent)) layout = false;
+		}
+		pages.push({
+			pattern: route.pattern,
+			params: route.params,
+			catchAll: route.catchAll,
+			componentPath: file,
+			serverPath,
+			methods,
+			componentId,
+			revalidate,
+			prerender,
+			hasGetPrerenderPaths,
+			island,
+			metadata,
+			layout
+		});
+	}
+	pages.sort((a, b) => {
+		if (a.catchAll !== b.catchAll) return a.catchAll ? 1 : -1;
+		const aDynamic = a.pattern.includes(":");
+		if (aDynamic !== b.pattern.includes(":")) return aDynamic ? 1 : -1;
+		return a.pattern.localeCompare(b.pattern);
+	});
+	for (const page of pages) {
+		if (page.island) continue;
+		const dir = dirname(page.componentPath);
+		const segments = dir === "." ? [] : dir.split("/");
+		let current = "";
+		if (layouts.some((l) => l.directory === "" && l.island)) throw new Error(`pages: Regular page '${page.componentPath}' is under an island layout. Add a .island suffix.`);
+		for (const seg of segments) {
+			current = current ? `${current}/${seg}` : seg;
+			if (layouts.some((l) => l.directory === current && l.island)) throw new Error(`pages: Regular page '${page.componentPath}' is under an island layout. Add a .island suffix.`);
+		}
+	}
+	for (const page of pages) {
+		if (page.layout === void 0 || page.layout === false) continue;
+		const name = page.layout.startsWith("!") ? page.layout.slice(1) : page.layout;
+		if (name.startsWith(".") || name.startsWith("/")) continue;
+		if (!resolveNamedLayout(name, page.componentId, namedLayouts)) throw new Error(`pages: Page '${page.componentPath}' specifies layout '${page.layout}', but _layouts/${name}.vue was not found in any ancestor directory.`);
+	}
+	return {
+		pages,
+		layouts,
+		namedLayouts
+	};
+}
+/** Extract title and description from YAML frontmatter in markdown source. */
+function extractFrontmatterMeta(source) {
+	const match = source.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+	if (!match) return;
+	const yaml = match[1];
+	const title = yaml.match(/^title:\s*(.+)$/m)?.[1]?.trim().replace(/^["']|["']$/g, "");
+	const description = yaml.match(/^description:\s*(.+)$/m)?.[1]?.trim().replace(/^["']|["']$/g, "");
+	if (!title && !description) return;
+	return {
+		title,
+		description
+	};
+}
+/** Extract layout field from YAML frontmatter in markdown source. */
+function extractFrontmatterLayout(source) {
+	const match = source.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+	if (!match) return;
+	const value = match[1].match(/^layout:\s*(.+)$/m)?.[1]?.trim().replace(/^["']|["']$/g, "");
+	if (!value) return;
+	if (value === "false") return false;
+	return value;
+}
+//#endregion
+export { resolveNamedLayout as a, resolveLayoutIds as i, resolveEffectiveLayoutChain as n, parseRouteFilename as o, resolveLayoutChain as r, parseWebSocketFilename as s, scanPages as t };