void 0.1.6 → 0.7.1

package/dist/pages/prefetch.mjs

@@ -0,0 +1,90 @@
+//#region src/pages/prefetch.ts
+const UNITS = {
+	ms: 1,
+	s: 1e3,
+	m: 6e4,
+	h: 36e5,
+	d: 864e5
+};
+function parseUnit(value) {
+	const match = value.match(/^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d)$/);
+	if (!match) throw new Error(`prefetch: Invalid cacheFor value '${value}'. Use a number with ms, s, m, h, or d.`);
+	return Number(match[1]) * UNITS[match[2]];
+}
+function parseCacheFor(value) {
+	if (typeof value === "number") return {
+		stale: value,
+		expires: value
+	};
+	if (Array.isArray(value)) return {
+		stale: parseUnit(value[0]),
+		expires: parseUnit(value[1])
+	};
+	const ms = parseUnit(value);
+	return {
+		stale: ms,
+		expires: ms
+	};
+}
+var PrefetchCache = class {
+	entries = /* @__PURE__ */ new Map();
+	key(url, method = "GET") {
+		return `${method}:${url}`;
+	}
+	has(url, method = "GET") {
+		return this.get(url, method) !== null;
+	}
+	get(url, method = "GET") {
+		const entry = this.entries.get(this.key(url, method));
+		if (!entry) return null;
+		if (Date.now() >= entry.expiresAt && !entry.singleUse) {
+			this.entries.delete(this.key(url, method));
+			return null;
+		}
+		return entry;
+	}
+	isFresh(entry) {
+		return Date.now() < entry.staleAt;
+	}
+	isUsable(entry) {
+		return Date.now() < entry.expiresAt || entry.singleUse;
+	}
+	set(url, method, response, ttl) {
+		const k = this.key(url, method);
+		const existing = this.entries.get(k);
+		if (existing && this.isUsable(existing)) return;
+		const now = Date.now();
+		const singleUse = ttl.stale === 0 && ttl.expires === 0;
+		const entry = {
+			url,
+			method,
+			response,
+			staleAt: now + ttl.stale,
+			expiresAt: now + ttl.expires,
+			singleUse,
+			timer: null
+		};
+		if (!singleUse && ttl.expires > 0) entry.timer = setTimeout(() => this.entries.delete(k), ttl.expires);
+		this.entries.set(k, entry);
+	}
+	/** Mark entry as consumed — removes it if singleUse. */
+	consume(url, method = "GET") {
+		const entry = this.entries.get(this.key(url, method));
+		if (entry?.singleUse) {
+			if (entry.timer) clearTimeout(entry.timer);
+			this.entries.delete(this.key(url, method));
+		}
+	}
+	flush(url, method = "GET") {
+		const k = this.key(url, method);
+		const entry = this.entries.get(k);
+		if (entry?.timer) clearTimeout(entry.timer);
+		this.entries.delete(k);
+	}
+	flushAll() {
+		for (const entry of this.entries.values()) if (entry.timer) clearTimeout(entry.timer);
+		this.entries.clear();
+	}
+};
+//#endregion
+export { PrefetchCache, parseCacheFor };

package/dist/pages/protocol.d.mts

@@ -0,0 +1,3 @@
+import { S as ValidationError } from "../handler-B0ds0OHJ.mjs";
+import { a as handlePageMutation, i as handlePageGet, n as PageRenderResult, o as safeJsonStringify, r as flattenValidationErrors, t as PageObject } from "../protocol-BWzXs2A2.mjs";
+export { PageObject, PageRenderResult, ValidationError, flattenValidationErrors, handlePageGet, handlePageMutation, safeJsonStringify };

package/dist/pages/protocol.mjs

@@ -0,0 +1,193 @@
+import { isConvertedResponse } from "../runtime/response.mjs";
+import { i as ValidationError, r as separateDeferred, t as DEFERRED } from "../defer-DcxEsVH1.mjs";
+import { resolveHead } from "./head.mjs";
+//#region src/pages/protocol.ts
+const POWERED_BY = { "X-Powered-By": "Void" };
+/** Escape characters that are unsafe inside inline <script> tags to prevent XSS. */
+function safeJsonStringify(value) {
+	return (JSON.stringify(value) ?? "null").replaceAll("<", "\\u003c").replaceAll(">", "\\u003e").replaceAll("&", "\\u0026").replaceAll("\u2028", "\\u2028").replaceAll("\u2029", "\\u2029");
+}
+function isPagesRequest(c) {
+	return c.req.header("x-voidpages") === "true";
+}
+function pageJsonResponse(pageObj) {
+	return Response.json(pageObj, { headers: {
+		"X-VoidPages": "true",
+		Vary: "X-VoidPages",
+		...POWERED_BY
+	} });
+}
+function requestPathWithSearch(c) {
+	return c.req.path + new URL(c.req.url).search;
+}
+/** Extract props from a handler result, handling Response wrapping from withValidator */
+async function extractProps(result) {
+	if (result instanceof Response) {
+		if ((result.headers.get("content-type") || "").includes("application/json")) return await result.json();
+		return {};
+	}
+	return result ?? {};
+}
+/** Flatten withValidator's { issues: [{ slot, issues: [{ message, path }] }] } into { field: message } */
+function flattenValidationErrors(body) {
+	const errors = {};
+	const issues = body?.issues;
+	if (issues) for (const slotIssue of issues) for (const issue of slotIssue.issues ?? []) {
+		const key = typeof issue.path === "string" ? issue.path : slotIssue.slot;
+		if (typeof key === "string") errors[key] = issue.message ?? "Invalid value";
+	}
+	return errors;
+}
+/** Strip deferred sentinels from props, setting their keys to null. Used by mutations. */
+function stripDeferred(props) {
+	const result = {};
+	for (const [key, value] of Object.entries(props)) if (value && typeof value === "object" && DEFERRED in value) result[key] = null;
+	else result[key] = value;
+	return result;
+}
+async function writeRenderResult(writer, encoder, result) {
+	if (typeof result === "string") {
+		await writer.write(encoder.encode(result));
+		return;
+	}
+	const reader = result.getReader();
+	while (true) {
+		const { done, value } = await reader.read();
+		if (done) return;
+		await writer.write(value);
+	}
+}
+function renderedResponse(result, contentType) {
+	return new Response(result, { headers: {
+		"content-type": contentType,
+		...POWERED_BY
+	} });
+}
+/** Build a streaming response that sends an initial chunk then streams deferred results. */
+function streamDeferredResponse(initialChunk, deferredMap, c, contentType, formatResolved, formatRejected) {
+	const encoder = new TextEncoder();
+	const { readable, writable } = new TransformStream();
+	const writer = writable.getWriter();
+	const pendingChunks = Object.entries(deferredMap).map(([group, { resolver }]) => resolver(c).then((data) => formatResolved(group, data)).catch((err) => formatRejected(group, err instanceof Error ? err.message : String(err))));
+	(async () => {
+		await writeRenderResult(writer, encoder, initialChunk);
+		await Promise.all(pendingChunks.map(async (chunk) => writer.write(encoder.encode(await chunk))));
+		await writer.close();
+	})().catch((error) => {
+		writer.abort(error).catch(() => {});
+	});
+	return new Response(readable, { headers: {
+		"content-type": contentType,
+		...POWERED_BY
+	} });
+}
+/** Handle GET page request — run handler, return page object or SSR HTML */
+async function handlePageGet(handler, headFn, c, componentId, renderFn, getAssetTags, configHead, island) {
+	const shared = c.get("shared") ?? {};
+	let props = {};
+	if (handler) {
+		const result = await handler(c);
+		if (result instanceof Response && !isConvertedResponse(result)) {
+			const ct = result.headers.get("content-type") || "";
+			if (result.status >= 300 || !ct.includes("application/json")) return result;
+		}
+		props = await extractProps(result);
+	}
+	const pageHead = headFn ? headFn(c, props) : void 0;
+	const head = resolveHead(configHead, c.get("headDefaults"), pageHead);
+	const { immediateProps, deferredMap } = separateDeferred(props);
+	const hasDeferred = Object.keys(deferredMap).length > 0;
+	const deferredKeys = {};
+	if (hasDeferred) for (const [group, { keys }] of Object.entries(deferredMap)) for (const key of keys) deferredKeys[key] = group;
+	const pageObj = {
+		component: componentId,
+		props: immediateProps,
+		shared,
+		url: requestPathWithSearch(c),
+		errors: null,
+		...head && { head },
+		...hasDeferred && {
+			deferred: Object.keys(deferredMap),
+			deferredKeys
+		}
+	};
+	if (!island && isPagesRequest(c)) {
+		if (c.req.header("purpose") === "prefetch" && hasDeferred) {
+			const resolvedProps = { ...immediateProps };
+			await Promise.all(Object.entries(deferredMap).map(async ([, { resolver, keys }]) => {
+				try {
+					const data = await resolver(c);
+					if (keys.length === 1) resolvedProps[keys[0]] = data;
+					else {
+						const obj = data;
+						for (const key of keys) resolvedProps[key] = obj[key];
+					}
+				} catch {
+					for (const key of keys) resolvedProps[key] = null;
+				}
+			}));
+			return pageJsonResponse({
+				...pageObj,
+				props: resolvedProps,
+				deferred: void 0
+			});
+		}
+		if (!hasDeferred) return pageJsonResponse(pageObj);
+		return streamDeferredResponse(JSON.stringify(pageObj) + "\n", deferredMap, c, "application/x-ndjson", (group, data) => JSON.stringify({
+			__deferred: group,
+			data
+		}) + "\n", (group, error) => JSON.stringify({
+			__deferred: group,
+			error
+		}) + "\n");
+	}
+	const html = await renderFn(pageObj, await getAssetTags(c.req.raw, c.env, componentId));
+	if (!hasDeferred) return renderedResponse(html, "text/html; charset=utf-8");
+	return streamDeferredResponse(html, deferredMap, c, "text/html; charset=utf-8", (group, data) => `\n<script>window.__resolveDeferred?window.__resolveDeferred(${safeJsonStringify(group)},${safeJsonStringify(data)}):(window.__deferredQueue??=[]).push([${safeJsonStringify(group)},${safeJsonStringify(data)}])<\/script>`, (group, error) => `\n<script>window.__rejectDeferred?window.__rejectDeferred(${safeJsonStringify(group)},${safeJsonStringify(error)}):(window.__deferredQueue??=[]).push([${safeJsonStringify(group)},0,${safeJsonStringify(error)}])<\/script>`);
+}
+/** Handle POST/PUT/DELETE page request — run mutation, then re-run GET or redirect */
+async function handlePageMutation(mutationHandler, getHandler, headFn, c, componentId, renderFn, getAssetTags, configHead, island) {
+	const shared = c.get("shared") ?? {};
+	const middlewareHead = c.get("headDefaults");
+	function buildMutationPageObj(props, errors) {
+		const head = resolveHead(configHead, middlewareHead, headFn ? headFn(c, props) : void 0);
+		return {
+			component: componentId,
+			props,
+			shared,
+			url: requestPathWithSearch(c),
+			errors,
+			...head && { head }
+		};
+	}
+	let result;
+	try {
+		result = mutationHandler ? await mutationHandler(c) : void 0;
+	} catch (e) {
+		if (e instanceof ValidationError) {
+			if (island) return Response.json({ errors: e.errors }, { status: 422 });
+			const pageObj = buildMutationPageObj(stripDeferred(getHandler ? await extractProps(await getHandler(c)) : {}), e.errors);
+			if (isPagesRequest(c)) return pageJsonResponse(pageObj);
+			return renderedResponse(await renderFn(pageObj, await getAssetTags(c.req.raw, c.env, componentId)), "text/html; charset=utf-8");
+		}
+		throw e;
+	}
+	if (result instanceof Response) {
+		const status = result.status;
+		if (status >= 300 && status < 400) return result;
+		if (status === 400) {
+			const errors = flattenValidationErrors(await result.json());
+			if (island) return Response.json({ errors }, { status: 422 });
+			const pageObj = buildMutationPageObj(stripDeferred(getHandler ? await extractProps(await getHandler(c)) : {}), errors);
+			if (isPagesRequest(c)) return pageJsonResponse(pageObj);
+			return renderedResponse(await renderFn(pageObj, await getAssetTags(c.req.raw, c.env, componentId)), "text/html; charset=utf-8");
+		}
+		if (status !== 204) return result;
+	}
+	if (island) return Response.json({ success: true });
+	const pageObj = buildMutationPageObj(stripDeferred(getHandler ? await extractProps(await getHandler(c)) : {}), null);
+	if (isPagesRequest(c)) return pageJsonResponse(pageObj);
+	return renderedResponse(await renderFn(pageObj, await getAssetTags(c.req.raw, c.env, componentId)), "text/html; charset=utf-8");
+}
+//#endregion
+export { ValidationError, flattenValidationErrors, handlePageGet, handlePageMutation, safeJsonStringify };

package/dist/pages/serialize.d.mts

@@ -0,0 +1,10 @@
+//#region src/pages/serialize.d.ts
+/**
+* Escape JSON for embedding inside an inline `<script type="application/json">`
+* tag. Replaces `<`, `>`, `&`, U+2028, U+2029 with their `\uXXXX` JSON escape
+* sequences so the script tag cannot be closed early and the payload survives
+* `JSON.parse` on hydration.
+*/
+declare function serializePageData(pageObj: unknown): string;
+//#endregion
+export { serializePageData };

package/dist/pages/serialize.mjs

@@ -0,0 +1,14 @@
+//#region src/pages/serialize.ts
+/**
+* Escape JSON for embedding inside an inline `<script type="application/json">`
+* tag. Replaces `<`, `>`, `&`, U+2028, U+2029 with their `\uXXXX` JSON escape
+* sequences so the script tag cannot be closed early and the payload survives
+* `JSON.parse` on hydration.
+*/
+function serializePageData(pageObj) {
+	return JSON.stringify(pageObj).replace(/[<>&\u2028\u2029]/g, (c) => {
+		return `\\u${c.charCodeAt(0).toString(16).padStart(4, "0")}`;
+	});
+}
+//#endregion
+export { serializePageData };

package/dist/pathe.M-eThtNZ-D-kmWkCS.mjs

@@ -0,0 +1,150 @@
+//#region ../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs
+const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+	if (!input) return input;
+	return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+const _UNC_REGEX = /^[/\\]{2}/;
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+const _ROOT_FOLDER_RE = /^\/([A-Za-z]:)?$/;
+const _EXTNAME_RE = /.(\.[^./]+|\.)$/;
+const normalize = function(path) {
+	if (path.length === 0) return ".";
+	path = normalizeWindowsPath(path);
+	const isUNCPath = path.match(_UNC_REGEX);
+	const isPathAbsolute = isAbsolute(path);
+	const trailingSeparator = path[path.length - 1] === "/";
+	path = normalizeString(path, !isPathAbsolute);
+	if (path.length === 0) {
+		if (isPathAbsolute) return "/";
+		return trailingSeparator ? "./" : ".";
+	}
+	if (trailingSeparator) path += "/";
+	if (_DRIVE_LETTER_RE.test(path)) path += "/";
+	if (isUNCPath) {
+		if (!isPathAbsolute) return `//./${path}`;
+		return `//${path}`;
+	}
+	return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
+};
+const join = function(...segments) {
+	let path = "";
+	for (const seg of segments) {
+		if (!seg) continue;
+		if (path.length > 0) {
+			const pathTrailing = path[path.length - 1] === "/";
+			const segLeading = seg[0] === "/";
+			if (pathTrailing && segLeading) path += seg.slice(1);
+			else path += pathTrailing || segLeading ? seg : `/${seg}`;
+		} else path += seg;
+	}
+	return normalize(path);
+};
+function cwd() {
+	if (typeof process !== "undefined" && typeof process.cwd === "function") return process.cwd().replace(/\\/g, "/");
+	return "/";
+}
+const resolve = function(...arguments_) {
+	arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+	let resolvedPath = "";
+	let resolvedAbsolute = false;
+	for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+		const path = index >= 0 ? arguments_[index] : cwd();
+		if (!path || path.length === 0) continue;
+		resolvedPath = `${path}/${resolvedPath}`;
+		resolvedAbsolute = isAbsolute(path);
+	}
+	resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+	if (resolvedAbsolute && !isAbsolute(resolvedPath)) return `/${resolvedPath}`;
+	return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path, allowAboveRoot) {
+	let res = "";
+	let lastSegmentLength = 0;
+	let lastSlash = -1;
+	let dots = 0;
+	let char = null;
+	for (let index = 0; index <= path.length; ++index) {
+		if (index < path.length) char = path[index];
+		else if (char === "/") break;
+		else char = "/";
+		if (char === "/") {
+			if (lastSlash === index - 1 || dots === 1);
+			else if (dots === 2) {
+				if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+					if (res.length > 2) {
+						const lastSlashIndex = res.lastIndexOf("/");
+						if (lastSlashIndex === -1) {
+							res = "";
+							lastSegmentLength = 0;
+						} else {
+							res = res.slice(0, lastSlashIndex);
+							lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+						}
+						lastSlash = index;
+						dots = 0;
+						continue;
+					} else if (res.length > 0) {
+						res = "";
+						lastSegmentLength = 0;
+						lastSlash = index;
+						dots = 0;
+						continue;
+					}
+				}
+				if (allowAboveRoot) {
+					res += res.length > 0 ? "/.." : "..";
+					lastSegmentLength = 2;
+				}
+			} else {
+				if (res.length > 0) res += `/${path.slice(lastSlash + 1, index)}`;
+				else res = path.slice(lastSlash + 1, index);
+				lastSegmentLength = index - lastSlash - 1;
+			}
+			lastSlash = index;
+			dots = 0;
+		} else if (char === "." && dots !== -1) ++dots;
+		else dots = -1;
+	}
+	return res;
+}
+const isAbsolute = function(p) {
+	return _IS_ABSOLUTE_RE.test(p);
+};
+const extname = function(p) {
+	if (p === "..") return "";
+	const match = _EXTNAME_RE.exec(normalizeWindowsPath(p));
+	return match && match[1] || "";
+};
+const relative = function(from, to) {
+	const _from = resolve(from).replace(_ROOT_FOLDER_RE, "$1").split("/");
+	const _to = resolve(to).replace(_ROOT_FOLDER_RE, "$1").split("/");
+	if (_to[0][1] === ":" && _from[0][1] === ":" && _from[0] !== _to[0]) return _to.join("/");
+	const _fromCopy = [..._from];
+	for (const segment of _fromCopy) {
+		if (_to[0] !== segment) break;
+		_from.shift();
+		_to.shift();
+	}
+	return [..._from.map(() => ".."), ..._to].join("/");
+};
+const dirname = function(p) {
+	const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
+	if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) segments[0] += "/";
+	return segments.join("/") || (isAbsolute(p) ? "/" : ".");
+};
+const basename = function(p, extension) {
+	const segments = normalizeWindowsPath(p).split("/");
+	let lastSegment = "";
+	for (let i = segments.length - 1; i >= 0; i--) {
+		const val = segments[i];
+		if (val) {
+			lastSegment = val;
+			break;
+		}
+	}
+	return extension && lastSegment.endsWith(extension) ? lastSegment.slice(0, -extension.length) : lastSegment;
+};
+//#endregion
+export { join as a, isAbsolute as i, dirname as n, relative as o, extname as r, resolve as s, basename as t };