void 0.22.0 → 0.23.0

package/dist/protocol-U7bfjHmA.mjs

@@ -0,0 +1,331 @@
+import { n as isConvertedResponse } from "./response-Tn7rU0MV.mjs";
+import { i as ValidationError, r as separateDeferred, t as DEFERRED } from "./defer-YsYDUoii.mjs";
+import { i as resolveHead, n as renderHeadToString, r as renderHtmlAttrs, t as renderBodyAttrs } from "./head-D_QRR5Yd.mjs";
+import { t as serializePageData } from "./serialize-BPvnNQuA.mjs";
+//#region src/pages/protocol.ts
+const POWERED_BY = { "X-Powered-By": "Void" };
+const RENDER_ERROR_ASSET_TAGS_KEY = "__voidPageAssetTags";
+/** 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 pageResponseHeaders(c, headers) {
+	const out = new Headers(c.res.headers);
+	for (const [key, value] of Object.entries(headers)) if (key.toLowerCase() === "vary") appendVary(out, value);
+	else out.set(key, value);
+	return out;
+}
+function appendVary(headers, name) {
+	const existing = headers.get("Vary")?.split(",").map((value) => value.trim().toLowerCase()) ?? [];
+	if (!existing.includes("*") && !existing.includes(name.toLowerCase())) headers.append("Vary", name);
+}
+function escapeHtmlAttr(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("\"", "&quot;").replaceAll("<", "&lt;");
+}
+function serializeStyleCss(css) {
+	return css.replace(/<\/style/gi, "<\\/style");
+}
+function serializeDevCssAssets(assets, nonce) {
+	return assets.map((asset) => `<style data-vite-dev-id="${escapeHtmlAttr(asset.id ?? asset.url)}" nonce="${escapeHtmlAttr(nonce)}">${serializeStyleCss(asset.css)}</style>`).join("\n");
+}
+function hasCompatibleStyleSource(value, nonceSource) {
+	return value === "'unsafe-inline'" || value === nonceSource;
+}
+function adjustCspValue(value, nonce) {
+	const nonceSource = `'nonce-${nonce}'`;
+	const parsed = value.split(";").map((part) => part.trim()).filter(Boolean).map((directive) => {
+		const [name = "", ...sources] = directive.split(/\s+/);
+		return {
+			name: name.toLowerCase(),
+			originalName: name,
+			sources
+		};
+	});
+	const styleElem = parsed.find((directive) => directive.name === "style-src-elem");
+	if (styleElem) {
+		if (!styleElem.sources.some((source) => hasCompatibleStyleSource(source, nonceSource))) styleElem.sources.push(nonceSource);
+		return parsed.map((directive) => [directive.originalName, ...directive.sources].join(" ")).join("; ");
+	}
+	const style = parsed.find((directive) => directive.name === "style-src");
+	if (style) {
+		if (!style.sources.some((source) => hasCompatibleStyleSource(source, nonceSource))) style.sources.push(nonceSource);
+		return parsed.map((directive) => [directive.originalName, ...directive.sources].join(" ")).join("; ");
+	}
+	const defaultSrc = parsed.find((directive) => directive.name === "default-src");
+	if (defaultSrc) {
+		parsed.push({
+			name: "style-src",
+			originalName: "style-src",
+			sources: [...defaultSrc.sources, nonceSource]
+		});
+		return parsed.map((directive) => [directive.originalName, ...directive.sources].join(" ")).join("; ");
+	}
+	parsed.push({
+		name: "style-src",
+		originalName: "style-src",
+		sources: [nonceSource]
+	});
+	return parsed.map((directive) => [directive.originalName, ...directive.sources].join(" ")).join("; ");
+}
+function adjustDevCssCsp(headers, nonce) {
+	if (!nonce) return headers;
+	const csp = headers.get("content-security-policy");
+	if (csp) headers.set("content-security-policy", adjustCspValue(csp, nonce));
+	const cspReportOnly = headers.get("content-security-policy-report-only");
+	if (cspReportOnly) headers.set("content-security-policy-report-only", adjustCspValue(cspReportOnly, nonce));
+	return headers;
+}
+function prepareAssetTags(assetTags) {
+	if (!assetTags.devCss || assetTags.devCss.length === 0) return assetTags;
+	const nonce = crypto.randomUUID().replaceAll("-", "");
+	return {
+		...assetTags,
+		css: [assetTags.css, serializeDevCssAssets(assetTags.devCss, nonce)].filter(Boolean).join("\n"),
+		devCssNonce: nonce
+	};
+}
+function attachRenderErrorAssetTags(error, assetTags) {
+	if ((typeof error === "object" || typeof error === "function") && error !== null) Object.defineProperty(error, RENDER_ERROR_ASSET_TAGS_KEY, {
+		configurable: true,
+		value: assetTags
+	});
+	throw error;
+}
+async function renderWithAssetTags(renderFn, pageObj, assetTags) {
+	try {
+		return await renderFn(pageObj, assetTags);
+	} catch (error) {
+		attachRenderErrorAssetTags(error, assetTags);
+	}
+}
+function renderClientOnlyPage(pageObj, assetTags, renderFn) {
+	const pageData = serializePageData(pageObj);
+	const headHtml = pageObj.head ? renderHeadToString(pageObj.head) : "";
+	const htmlAttrs = pageObj.head ? renderHtmlAttrs(pageObj.head) : "";
+	const bodyAttrs = pageObj.head ? renderBodyAttrs(pageObj.head) : "";
+	return `<!doctype html>
+<html${htmlAttrs}>
+<head>${headHtml}${typeof renderFn.preambleScript === "string" ? renderFn.preambleScript : ""}${assetTags.css}${assetTags.preloads}</head>
+<body${bodyAttrs}>
+  <script id="__VOID_PAGE_DATA__" type="application/json">${pageData}<\/script>
+  <div id="app" data-void-ssr="false"></div>
+  ${assetTags.body}
+</body>
+</html>`;
+}
+function pageJsonResponse(c, pageObj) {
+	return Response.json(pageObj, { headers: pageResponseHeaders(c, {
+		"X-VoidPages": "true",
+		Vary: "X-VoidPages",
+		...POWERED_BY
+	}) });
+}
+function requestPathWithSearch(c) {
+	return c.req.path + new URL(c.req.url).search;
+}
+function requestParams(c) {
+	return c.req.param();
+}
+/** 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(c, result, contentType, assetTags) {
+	return new Response(result, { headers: adjustDevCssCsp(pageResponseHeaders(c, {
+		"content-type": contentType,
+		...POWERED_BY
+	}), assetTags?.devCssNonce) });
+}
+/** Build a streaming response that sends an initial chunk then streams deferred results. */
+function streamDeferredResponse(initialChunk, deferredMap, c, contentType, formatResolved, formatRejected, assetTags) {
+	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: adjustDevCssCsp(pageResponseHeaders(c, {
+		"content-type": contentType,
+		...POWERED_BY
+	}), assetTags?.devCssNonce) });
+}
+/** Handle GET page request — run handler, return page object or SSR HTML */
+async function handlePageGet(handler, headFn, c, componentId, renderFn, getAssetTags, configHead, options) {
+	const renderMode = options?.renderMode ?? "server";
+	const shared = c.get("shared") ?? {};
+	let props = {};
+	if (handler) {
+		const result = await handler(c);
+		if (result instanceof Response && !isConvertedResponse(result)) {
+			const contentType = result.headers.get("content-type") || "";
+			if (result.status >= 300 || !contentType.includes("application/json")) return result;
+		}
+		props = await extractProps(result);
+	}
+	const pageHead = headFn ? headFn(c, props) : void 0;
+	const middlewareHead = c.get("headDefaults");
+	const head = resolveHead(configHead, middlewareHead, 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,
+		params: requestParams(c),
+		shared,
+		url: requestPathWithSearch(c),
+		errors: null,
+		...head && { head },
+		...hasDeferred && {
+			deferred: Object.keys(deferredMap),
+			deferredKeys
+		}
+	};
+	if (renderMode !== "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(c, {
+				...pageObj,
+				props: resolvedProps,
+				deferred: void 0
+			});
+		}
+		if (!hasDeferred) return pageJsonResponse(c, pageObj);
+		c.header("X-VoidPages", "true");
+		const headers = new Headers(c.res.headers);
+		appendVary(headers, "X-VoidPages");
+		c.header("Vary", headers.get("Vary"));
+		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 assetTags = prepareAssetTags(await getAssetTags(c.req.raw, c.env, componentId));
+	const html = renderMode === "client" ? renderClientOnlyPage(pageObj, assetTags, renderFn) : await renderWithAssetTags(renderFn, pageObj, assetTags);
+	if (!hasDeferred) return renderedResponse(c, html, "text/html; charset=utf-8", assetTags);
+	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>`, assetTags);
+}
+function isSameOriginAction(request) {
+	const origin = new URL(request.url).origin;
+	const suppliedOrigin = request.headers.get("Origin");
+	if (suppliedOrigin !== null) return suppliedOrigin === origin;
+	const site = request.headers.get("Sec-Fetch-Site");
+	if (site && site !== "same-origin" && site !== "none") return false;
+	const referer = request.headers.get("Referer");
+	if (referer !== null) try {
+		return new URL(referer).origin === origin;
+	} catch {
+		return false;
+	}
+	return true;
+}
+/** Handle POST/PUT/PATCH/DELETE page request — run mutation, then re-run GET or redirect */
+async function handlePageMutation(mutationHandler, getHandler, headFn, c, componentId, renderFn, getAssetTags, configHead, options) {
+	if (!isSameOriginAction(c.req.raw)) return new Response("Cross-origin page actions are not allowed.", { status: 403 });
+	const renderMode = options?.renderMode ?? "server";
+	const shared = c.get("shared") ?? {};
+	const middlewareHead = c.get("headDefaults");
+	function buildMutationPageObj(props, errors) {
+		const pageHead = headFn ? headFn(c, props) : void 0;
+		const head = resolveHead(configHead, middlewareHead, pageHead);
+		return {
+			component: componentId,
+			props,
+			params: requestParams(c),
+			shared,
+			url: requestPathWithSearch(c),
+			errors,
+			...head && { head }
+		};
+	}
+	let result;
+	try {
+		result = mutationHandler ? await mutationHandler(c) : void 0;
+	} catch (e) {
+		if (e instanceof ValidationError) {
+			if (renderMode === "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(c, pageObj);
+			const assetTags = prepareAssetTags(await getAssetTags(c.req.raw, c.env, componentId));
+			return renderedResponse(c, renderMode === "client" ? renderClientOnlyPage(pageObj, assetTags, renderFn) : await renderWithAssetTags(renderFn, pageObj, assetTags), "text/html; charset=utf-8", assetTags);
+		}
+		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 (renderMode === "island") return Response.json({ errors }, { status: 422 });
+			const pageObj = buildMutationPageObj(stripDeferred(getHandler ? await extractProps(await getHandler(c)) : {}), errors);
+			if (isPagesRequest(c)) return pageJsonResponse(c, pageObj);
+			const assetTags = prepareAssetTags(await getAssetTags(c.req.raw, c.env, componentId));
+			return renderedResponse(c, renderMode === "client" ? renderClientOnlyPage(pageObj, assetTags, renderFn) : await renderWithAssetTags(renderFn, pageObj, assetTags), "text/html; charset=utf-8", assetTags);
+		}
+		if (status !== 204) return result;
+	}
+	if (renderMode === "island") return Response.json({ success: true });
+	const pageObj = buildMutationPageObj(stripDeferred(getHandler ? await extractProps(await getHandler(c)) : {}), null);
+	if (isPagesRequest(c)) return pageJsonResponse(c, pageObj);
+	const assetTags = prepareAssetTags(await getAssetTags(c.req.raw, c.env, componentId));
+	return renderedResponse(c, renderMode === "client" ? renderClientOnlyPage(pageObj, assetTags, renderFn) : await renderWithAssetTags(renderFn, pageObj, assetTags), "text/html; charset=utf-8", assetTags);
+}
+//#endregion
+export { safeJsonStringify as i, handlePageGet as n, handlePageMutation as r, flattenValidationErrors as t };

package/dist/{provision-Fr9pRqce.mjs → provision-C4ORE7G7.mjs}

@@ -1,3 +1,3 @@
 import { r as scanWranglerDotenvKeys } from "./dotenv-VQxupEUv.mjs";
-import { _ as resolvePinnedApiBaseUrl, a as checkCloudflareProvisionDrift, c as enableD1ReadReplicationViaApi, d as isQueueConfirmedAbsent, f as isRealD1Id, g as provisionEnv, h as provisionCloudflareResources, i as assertValidResourceName, l as isAlreadyGoneKillError, m as normalizeRunWranglerResult, n as acquireProvisionLock, o as createDefaultRunWrangler, p as isRealKvId, r as assertNoTransportRedirectInProjectDotenv, s as deleteEnvVarCaseAware, t as WranglerQuarantineError, u as isQuarantineError, v as resolveProperLockfileKey } from "./provision-C4IGqkBf.mjs";
+import { _ as resolvePinnedApiBaseUrl, a as checkCloudflareProvisionDrift, c as enableD1ReadReplicationViaApi, d as isQueueConfirmedAbsent, f as isRealD1Id, g as provisionEnv, h as provisionCloudflareResources, i as assertValidResourceName, l as isAlreadyGoneKillError, m as normalizeRunWranglerResult, n as acquireProvisionLock, o as createDefaultRunWrangler, p as isRealKvId, r as assertNoTransportRedirectInProjectDotenv, s as deleteEnvVarCaseAware, t as WranglerQuarantineError, u as isQuarantineError, v as resolveProperLockfileKey } from "./provision-CJFgTZY8.mjs";
 export { WranglerQuarantineError, acquireProvisionLock, assertNoTransportRedirectInProjectDotenv, assertValidResourceName, checkCloudflareProvisionDrift, createDefaultRunWrangler, deleteEnvVarCaseAware, enableD1ReadReplicationViaApi, isAlreadyGoneKillError, isQuarantineError, isQueueConfirmedAbsent, isRealD1Id, isRealKvId, normalizeRunWranglerResult, provisionCloudflareResources, provisionEnv, resolvePinnedApiBaseUrl, resolveProperLockfileKey, scanWranglerDotenvKeys };