@bgub/fig-server 0.1.0-alpha.1 → 0.1.0-alpha.3

package/dist-development/payload.js

@@ -0,0 +1,602 @@
+import { a as componentStack, c as errorMessage, d as streamHighWaterMark, f as withContextValue, i as cloneContextValues, n as suppressesImagePreloads, o as createStaticDispatcher, s as deferred, t as imagePreloadFromHostProps, u as streamFlowBlocked } from "./image-preloads-D3OBEaWp.js";
+import { Fragment, isValidElement } from "@bgub/fig";
+import { assetResourceDestination, assetResourceKey, checkpointPayloadGraph, clientOnlyHostBehavior, clientReferenceAssets, createPayloadGraphEncodeContext, createRendererDataStore, definePayloadGraphElement, describeInvalidChild, encodePayloadDataEntries, encodePayloadValueWithGraph, isActivity, isAssets, isClientReference, isContext, isErrorBoundary, isFigAssetResource, isPlainPayloadValue, isPortal, isSuspense, isThenable, isViewTransition, jsonPayloadCodec, readThenable, rollbackPayloadGraph, serializePayloadArray, serializePayloadMap, serializePayloadPlainObject, serializePayloadSet, setCurrentDataStore, setCurrentDispatcher } from "@bgub/fig/internal";
+//#region src/payload.ts
+var PayloadRequestCancelledError = class extends Error {
+	constructor() {
+		super("Payload request cancelled.");
+		this.name = "PayloadRequestCancelledError";
+	}
+};
+const errorStacks = /* @__PURE__ */ new WeakMap();
+const childrenTreeProps = /* @__PURE__ */ new Set(["children"]);
+const emptyTreeProps = /* @__PURE__ */ new Set();
+const suspenseTreeProps = /* @__PURE__ */ new Set(["children", "fallback"]);
+function renderToPayloadStream(node, options = {}) {
+	const { request, stream } = createPayloadRequest(node, options);
+	return {
+		allReady: request.allReady.promise,
+		contentType: jsonPayloadCodec.contentType,
+		stream
+	};
+}
+function createPayloadRequest(node, options) {
+	throwIfAborted(options.signal);
+	const pendingDataSnapshots = /* @__PURE__ */ new Map();
+	const request = {
+		allReady: deferred(),
+		cleanupAbortListener: () => void 0,
+		clientReferenceRows: /* @__PURE__ */ new Map(),
+		clientReferenceAssets: options.clientReferenceAssets,
+		componentAssets: options.componentAssets,
+		controller: null,
+		dataStore: createRendererDataStore({
+			getLane: () => null,
+			onEntryChange: (entry) => {
+				pendingDataSnapshots.set(entry.canonicalKey, entry);
+			},
+			partition: options.dataPartition,
+			schedule: () => void 0
+		}),
+		emittedAssetKeys: /* @__PURE__ */ new Set(),
+		emittedDataKeys: /* @__PURE__ */ new Set(),
+		graph: createPayloadGraphEncodeContext(),
+		nextRowId: 1,
+		nextUseId: 0,
+		onError: options.onError,
+		pendingDataSnapshots,
+		pendingTasks: 0,
+		pingedTasks: [],
+		queuedRows: [],
+		flushingRows: false,
+		status: "open",
+		workScheduled: false
+	};
+	request.allReady.promise.catch(() => void 0);
+	request.pingedTasks.push(createTask(request, 0, {
+		kind: "node",
+		value: node
+	}, /* @__PURE__ */ new Map(), false, null));
+	const stream = new ReadableStream({
+		start(controller) {
+			request.controller = controller;
+			flushRows(request);
+		},
+		pull() {
+			flushRows(request);
+		},
+		cancel(reason) {
+			abortPayloadRequest(request, reason);
+		}
+	}, new ByteLengthQueuingStrategy({ highWaterMark: streamHighWaterMark(options.highWaterMark) }));
+	const signal = options.signal;
+	if (signal !== void 0) {
+		const abortListener = () => abortPayloadRequest(request, signal.reason);
+		signal.addEventListener("abort", abortListener, { once: true });
+		request.cleanupAbortListener = () => {
+			signal.removeEventListener("abort", abortListener);
+			request.cleanupAbortListener = () => void 0;
+		};
+	}
+	scheduleWork(request);
+	return {
+		request,
+		stream
+	};
+}
+function createTask(request, id, value, contextValues, imagePreloadsSuppressed, stack) {
+	request.pendingTasks += 1;
+	return {
+		contextValues,
+		id,
+		imagePreloadsSuppressed,
+		stack,
+		...value
+	};
+}
+function performWork(request) {
+	if (request.status === "closed") return;
+	const tasks = request.pingedTasks;
+	request.pingedTasks = [];
+	for (const task of tasks) retryTask(request, task);
+	flushRows(request);
+}
+function retryTask(request, task) {
+	const frame = {
+		contextValues: cloneContextValues(task.contextValues),
+		dispatcher: null,
+		pendingAssets: [],
+		request,
+		imagePreloadsSuppressed: task.imagePreloadsSuppressed,
+		stack: task.stack
+	};
+	try {
+		let value;
+		switch (task.kind) {
+			case "node":
+				value = serializeNode(task.value, frame);
+				break;
+			case "node-promise":
+				value = serializeNode(readThenable(task.value), frame);
+				break;
+			case "promise":
+				value = serializeValue(readThenable(task.value), frame);
+				break;
+		}
+		flushFrameAssets(frame, task.id);
+		emitDataRows(request);
+		emitRow(request, {
+			id: task.id,
+			tag: "model",
+			value
+		});
+		finishTask(request);
+	} catch (error) {
+		if (isThenable(error)) {
+			flushFrameAssets(frame, task.id);
+			error.then(() => pingTask(request, task), () => pingTask(request, task));
+			return;
+		}
+		flushFrameAssets(frame, task.id);
+		emitRow(request, {
+			id: task.id,
+			tag: "error",
+			value: errorRowPayload(request, error, task.stack)
+		});
+		finishTask(request);
+	}
+}
+function finishTask(request) {
+	request.pendingTasks -= 1;
+	if (request.pendingTasks === 0) request.allReady.resolve(void 0);
+}
+function emitDataRows(request) {
+	const entries = [];
+	for (const snapshot of request.pendingDataSnapshots.values()) {
+		if (!snapshot.hasValue || snapshot.status === "refreshing") continue;
+		const key = snapshot.canonicalKey;
+		if (request.emittedDataKeys.has(key)) {
+			request.pendingDataSnapshots.delete(snapshot.canonicalKey);
+			continue;
+		}
+		request.emittedDataKeys.add(key);
+		request.pendingDataSnapshots.delete(snapshot.canonicalKey);
+		entries.push({
+			key: snapshot.key,
+			value: snapshot.value
+		});
+	}
+	if (entries.length > 0) emitRow(request, {
+		tag: "data",
+		value: encodePayloadDataEntries(entries)
+	});
+}
+function flushFrameAssets(frame, rowId) {
+	if (frame.pendingAssets.length === 0) return;
+	const value = frame.pendingAssets.splice(0);
+	emitRow(frame.request, {
+		for: rowId,
+		tag: "assets",
+		value
+	});
+}
+function createPayloadDispatcher(frame) {
+	const dispatcher = createStaticDispatcher({
+		contextValues: frame.contextValues,
+		externalStoreError: "useSyncExternalStore requires getServerSnapshot during payload render.",
+		readPromise: readThenable,
+		readData(resource, args) {
+			return frame.request.dataStore.readData(resource, args, frame);
+		},
+		preloadData(resource, args) {
+			frame.request.dataStore.preloadData(resource, ...args);
+		},
+		useId() {
+			const id = `fig-pl-${frame.request.nextUseId.toString(32)}`;
+			frame.request.nextUseId += 1;
+			return id;
+		},
+		updateError: "State updates are not allowed during payload render."
+	});
+	{
+		const throwClientApi = (hook) => () => {
+			throw new Error(`${hook} cannot be used during payload render: serialized components are render-only. Move state, effects, and interactivity into a client reference.`);
+		};
+		dispatcher.useState = throwClientApi("useState");
+		dispatcher.useActionState = throwClientApi("useActionState");
+		dispatcher.useTransition = throwClientApi("useTransition");
+		dispatcher.useStableEvent = throwClientApi("useStableEvent");
+		dispatcher.useReactive = throwClientApi("useReactive");
+		dispatcher.useBeforePaint = throwClientApi("useBeforePaint");
+		dispatcher.useBeforeLayout = throwClientApi("useBeforeLayout");
+	}
+	return dispatcher;
+}
+function serializeNode(node, frame) {
+	if (Array.isArray(node)) return flattenChildArrays(node).map((child) => serializeNodeOrLazy(child, frame));
+	if (node === null || node === void 0 || typeof node === "boolean") return node === void 0 ? { $fig: "undefined" } : node;
+	if (typeof node === "string" || typeof node === "number") return node;
+	if (isPortal(node)) return null;
+	if (isValidElement(node)) return serializeElement(node, frame, false);
+	if (isThenable(node)) return outlineTask(frame, {
+		kind: "node-promise",
+		value: node
+	}, "promise", node);
+	throw invalidChildError$1(node);
+}
+function serializeNodeOrLazy(node, frame, preserveElementIdentity = false) {
+	const graphCheckpoint = checkpointPayloadGraph(frame.request.graph);
+	const assetCheckpoint = frame.pendingAssets.length;
+	try {
+		if (!isValidElement(node)) return serializeNode(node, frame);
+		return serializeElement(node, frame, preserveElementIdentity);
+	} catch (error) {
+		rollbackPayloadGraph(frame.request.graph, graphCheckpoint);
+		const scopedAssets = frame.pendingAssets.splice(assetCheckpoint);
+		if (isThenable(error)) return outlineTask(frame, {
+			kind: "node",
+			value: node
+		}, "lazy", error, scopedAssets);
+		return outlineError(frame, error, "lazy", scopedAssets);
+	}
+}
+function serializeElement(element, frame, preserveIdentity) {
+	const type = element.type;
+	if (typeof type === "string") return serializeHostElement(element, type, frame, preserveIdentity);
+	if (type === Fragment) return serializeElementModel(element, { $fig: "fragment" }, frame, preserveIdentity, childrenTreeProps);
+	if (isClientReference(type)) return serializeElementModel(element, {
+		$fig: "client",
+		id: emitClientReference(frame.request, type)
+	}, frame, preserveIdentity);
+	if (isContext(type)) return serializeContextProvider(type, element.props, frame);
+	if (isAssets(type)) return serializeAssets(element.props, frame);
+	if (isSuspense(type)) return serializeElementModel(element, { $fig: "suspense" }, frame, preserveIdentity, suspenseTreeProps);
+	if (isErrorBoundary(type)) return serializeNode(element.props.children, frame);
+	if (isActivity(type)) return serializeNode(element.props.children, frame);
+	if (isViewTransition(type)) return serializeElementModel(element, { $fig: "view-transition" }, frame, preserveIdentity, childrenTreeProps);
+	if (typeof type === "function") return serializeFunctionComponent(type, element.props, frame);
+	throw new Error("Unsupported Fig element type during payload render.");
+}
+function serializeHostElement(element, type, frame, preserveIdentity) {
+	const preload = imagePreloadFromHostProps(type, element.props, frame.imagePreloadsSuppressed);
+	if (preload !== null) frame.pendingAssets.push(...serializeAssetResources(frame.request, preload));
+	const previousImagePreloadsSuppressed = frame.imagePreloadsSuppressed;
+	frame.imagePreloadsSuppressed = previousImagePreloadsSuppressed || suppressesImagePreloads(type);
+	try {
+		return serializeElementModel(element, type, frame, preserveIdentity, childrenTreeProps);
+	} finally {
+		frame.imagePreloadsSuppressed = previousImagePreloadsSuppressed;
+	}
+}
+function serializeElementModel(element, type, frame, preserveIdentity, treeProps = emptyTreeProps) {
+	const id = preserveIdentity ? definePayloadGraphElement(frame.request.graph, element) : void 0;
+	if (typeof id === "object") return id;
+	const model = {
+		$fig: "element",
+		key: element.key,
+		props: serializeProps(element.props, frame, treeProps, typeof type === "string"),
+		type
+	};
+	if (id !== void 0) model.id = id;
+	return model;
+}
+function serializeFunctionComponent(type, props, frame) {
+	const assetCheckpoint = frame.pendingAssets.length;
+	frame.pendingAssets.push(...serializeAssetResources(frame.request, frame.request.componentAssets?.(type)));
+	frame.dispatcher ??= createPayloadDispatcher(frame);
+	const previousDispatcher = setCurrentDispatcher(frame.dispatcher);
+	const previousDataStore = setCurrentDataStore(frame.request.dataStore);
+	const previousStack = frame.stack;
+	frame.stack = {
+		name: type.name || "Anonymous",
+		parent: previousStack
+	};
+	try {
+		if ("$$typeof" in type && type.$$typeof === Symbol.for("fig.data-resource")) throw new Error("Payload components cannot be rendered inside Payload. Render the underlying server component directly, or mount separate Payload components from the client tree.");
+		const result = type(props);
+		if (isThenable(result)) {
+			const scopedAssets = frame.pendingAssets.splice(assetCheckpoint);
+			return outlineTask(frame, {
+				kind: "node-promise",
+				value: result
+			}, "promise", result, scopedAssets);
+		}
+		return serializeNode(result, frame);
+	} catch (error) {
+		recordErrorStack(error, frame.stack);
+		throw error;
+	} finally {
+		frame.stack = previousStack;
+		setCurrentDataStore(previousDataStore);
+		setCurrentDispatcher(previousDispatcher);
+	}
+}
+function serializeContextProvider(context, props, frame) {
+	return withContextValue(frame.contextValues, context, props.value, () => serializeNode(props.children, frame));
+}
+function serializeAssets(props, frame) {
+	frame.pendingAssets.push(...serializeAssetResources(frame.request, props.assets));
+	return serializeNode(props.children, frame);
+}
+function serializeProps(props, frame, treeProps, hostElement = false) {
+	const clientOnlyBehavior = hostElement ? clientOnlyHostBehavior(props) : void 0;
+	if (clientOnlyBehavior !== void 0) throw new Error(`Client-only host behavior from ${clientOnlyBehavior} cannot be serialized in a payload; move it into a client reference.`);
+	const value = {};
+	for (const name of Object.keys(props)) {
+		if (hostElement && name === "mix") continue;
+		const child = props[name];
+		value[name] = treeProps.has(name) ? serializeTreeProp(child, frame) : serializeValue(child, frame);
+	}
+	return {
+		$fig: "object",
+		value
+	};
+}
+function serializeTreeProp(value, frame) {
+	if (Array.isArray(value)) return flattenChildArrays(value).map((child) => serializeNodeOrLazy(child, frame));
+	return serializeNodeOrLazy(value, frame);
+}
+function serializeValue(value, frame) {
+	if (isPlainPayloadValue(value)) return encodePayloadValueWithGraph(value, frame.request.graph);
+	if (isClientReference(value)) return {
+		$fig: "client",
+		id: emitClientReference(frame.request, value)
+	};
+	if (isValidElement(value)) return serializeNodeOrLazy(value, frame, true);
+	if (isPortal(value)) return null;
+	if (isThenable(value)) return outlineTask(frame, {
+		kind: "promise",
+		value
+	}, "promise", value);
+	if (typeof value === "function") throw new Error("Functions cannot be passed to client references.");
+	if (typeof value === "object" && value !== null) {
+		if (value instanceof Date) return encodePayloadValueWithGraph(value, frame.request.graph);
+		if (value instanceof Map) return serializePayloadMap(value, frame.request.graph, ([key, item]) => [serializeValue(key, frame), serializeValue(item, frame)]);
+		if (value instanceof Set) return serializePayloadSet(value, frame.request.graph, (item) => serializeValue(item, frame));
+		if (Array.isArray(value)) return serializePayloadArray(value, frame.request.graph, () => value, (item) => serializeValue(item, frame));
+		return serializePayloadPlainObject(value, frame.request.graph, (child) => serializeValue(child, frame));
+	}
+	throw new Error(`Cannot serialize ${typeof value} into the payload.`);
+}
+function outlineTask(frame, value, referenceKind, wakeable, scopedAssets = []) {
+	const request = frame.request;
+	const id = request.nextRowId++;
+	if (scopedAssets.length > 0) emitRow(request, {
+		for: id,
+		tag: "assets",
+		value: scopedAssets
+	});
+	const task = createTask(request, id, value, cloneContextValues(frame.contextValues), frame.imagePreloadsSuppressed, stackForError(wakeable, frame.stack));
+	wakeable.then(() => pingTask(request, task), () => pingTask(request, task));
+	return {
+		$fig: referenceKind,
+		id
+	};
+}
+function outlineError(frame, error, referenceKind, scopedAssets) {
+	const request = frame.request;
+	const id = request.nextRowId++;
+	if (scopedAssets.length > 0) emitRow(request, {
+		for: id,
+		tag: "assets",
+		value: scopedAssets
+	});
+	emitRow(request, {
+		id,
+		tag: "error",
+		value: errorRowPayload(request, error, frame.stack)
+	});
+	return {
+		$fig: referenceKind,
+		id
+	};
+}
+function errorRowPayload(request, error, stack) {
+	const info = { componentStack: componentStack(stackForError(error, stack)) };
+	if (request.onError === void 0) return { message: errorMessage(error) };
+	try {
+		return request.onError(error, info) ?? {};
+	} catch {
+		return {};
+	}
+}
+function recordErrorStack(error, stack) {
+	if (stack === null) return;
+	if (typeof error !== "object" || error === null) return;
+	if (!errorStacks.has(error)) errorStacks.set(error, stack);
+}
+function stackForError(error, fallback) {
+	if (typeof error !== "object" || error === null) return fallback;
+	return errorStacks.get(error) ?? fallback;
+}
+function clientReferenceExportName(id) {
+	const hashIndex = id.lastIndexOf("#");
+	if (hashIndex === -1) return void 0;
+	return id.slice(hashIndex + 1) || void 0;
+}
+function emitClientReference(request, reference) {
+	const existing = request.clientReferenceRows.get(reference.id);
+	if (existing !== void 0) return existing;
+	const assets = serializeAssetResources(request, collectClientReferenceAssets(request, reference));
+	const value = { id: reference.id };
+	if (assets.length > 0) value.assets = assets;
+	const exportName = clientReferenceExportName(reference.id);
+	if (exportName !== void 0) value.exportName = exportName;
+	if (reference.ssr !== void 0) value.ssr = true;
+	const id = request.nextRowId++;
+	request.clientReferenceRows.set(reference.id, id);
+	emitRow(request, {
+		id,
+		tag: "client",
+		value
+	});
+	return id;
+}
+function serializeAssetResources(request, value) {
+	const input = isFigAssetResource(value) ? [value] : Array.isArray(value) ? value : [];
+	const resources = [];
+	for (const resource of input) {
+		if (!isFigAssetResource(resource)) continue;
+		if (assetResourceDestination(resource) === "stream") {
+			const key = assetResourceKey(resource);
+			if (request.emittedAssetKeys.has(key)) continue;
+			request.emittedAssetKeys.add(key);
+		}
+		resources.push(serializeAssetResource(resource));
+	}
+	return resources;
+}
+function collectClientReferenceAssets(request, reference) {
+	const resources = [...clientReferenceAssets(reference)];
+	const resolved = request.clientReferenceAssets?.({ id: reference.id });
+	if (resolved === void 0) return resources;
+	if (isFigAssetResource(resolved)) return [...resources, resolved];
+	return Array.isArray(resolved) ? [...resources, ...resolved] : resources;
+}
+function serializeAssetResource(resource) {
+	switch (resource.kind) {
+		case "stylesheet": {
+			const model = {
+				href: resource.href,
+				kind: resource.kind
+			};
+			if (resource.crossorigin !== void 0) model.crossorigin = resource.crossorigin;
+			if (resource.media !== void 0) model.media = resource.media;
+			if (resource.precedence !== void 0) model.precedence = resource.precedence;
+			return model;
+		}
+		case "preload": {
+			const model = {
+				as: resource.as,
+				kind: resource.kind
+			};
+			if (resource.crossorigin !== void 0) model.crossorigin = resource.crossorigin;
+			if (resource.fetchpriority !== void 0) model.fetchpriority = resource.fetchpriority;
+			if (resource.href !== void 0) model.href = resource.href;
+			if (resource.imagesizes !== void 0) model.imagesizes = resource.imagesizes;
+			if (resource.imagesrcset !== void 0) model.imagesrcset = resource.imagesrcset;
+			if (resource.referrerpolicy !== void 0) model.referrerpolicy = resource.referrerpolicy;
+			if (resource.type !== void 0) model.type = resource.type;
+			return model;
+		}
+		case "modulepreload": {
+			const model = {
+				href: resource.href,
+				kind: resource.kind
+			};
+			if (resource.crossorigin !== void 0) model.crossorigin = resource.crossorigin;
+			if (resource.fetchpriority !== void 0) model.fetchpriority = resource.fetchpriority;
+			return model;
+		}
+		case "script": {
+			const model = {
+				kind: resource.kind,
+				src: resource.src
+			};
+			if (resource.async !== void 0) model.async = resource.async;
+			if (resource.crossorigin !== void 0) model.crossorigin = resource.crossorigin;
+			if (resource.defer !== void 0) model.defer = resource.defer;
+			if (resource.module !== void 0) model.module = resource.module;
+			return model;
+		}
+		case "font": {
+			const model = {
+				href: resource.href,
+				kind: resource.kind,
+				type: resource.type
+			};
+			if (resource.crossorigin !== void 0) model.crossorigin = resource.crossorigin;
+			if (resource.fetchpriority !== void 0) model.fetchpriority = resource.fetchpriority;
+			return model;
+		}
+		case "preconnect": {
+			const model = {
+				href: resource.href,
+				kind: resource.kind
+			};
+			if (resource.crossorigin !== void 0) model.crossorigin = resource.crossorigin;
+			return model;
+		}
+		case "title": return {
+			kind: resource.kind,
+			value: resource.value
+		};
+		case "meta": {
+			const model = { kind: resource.kind };
+			if (resource.charset !== void 0) model.charset = resource.charset;
+			if (resource.content !== void 0) model.content = resource.content;
+			if (resource["http-equiv"] !== void 0) model["http-equiv"] = resource["http-equiv"];
+			if (resource.key !== void 0) model.key = resource.key;
+			if (resource.name !== void 0) model.name = resource.name;
+			if (resource.property !== void 0) model.property = resource.property;
+			return model;
+		}
+	}
+}
+function emitRow(request, row) {
+	request.queuedRows.push(jsonPayloadCodec.encodeRow(row));
+	flushRows(request);
+}
+function pingTask(request, task) {
+	if (request.status === "closed") return;
+	request.pingedTasks.push(task);
+	scheduleWork(request);
+}
+function scheduleWork(request) {
+	if (request.workScheduled) return;
+	request.workScheduled = true;
+	queueMicrotask(() => {
+		request.workScheduled = false;
+		performWork(request);
+	});
+}
+function flushRows(request) {
+	if (request.controller === null || request.status === "closed") return;
+	if (request.flushingRows) return;
+	request.flushingRows = true;
+	try {
+		let flushed = 0;
+		while (flushed < request.queuedRows.length && !streamFlowBlocked(request.controller)) {
+			request.controller.enqueue(request.queuedRows[flushed]);
+			flushed += 1;
+		}
+		if (flushed === request.queuedRows.length) request.queuedRows.length = 0;
+		else if (flushed > 0) request.queuedRows = request.queuedRows.slice(flushed);
+	} finally {
+		request.flushingRows = false;
+	}
+	if (request.pendingTasks === 0 && request.queuedRows.length === 0) {
+		request.status = "closed";
+		request.cleanupAbortListener();
+		request.dataStore.dispose();
+		request.controller.close();
+	}
+}
+function closeWithError(request, error) {
+	if (request.status === "closed") return;
+	request.cleanupAbortListener();
+	request.status = "closed";
+	request.dataStore.dispose();
+	request.allReady.reject(error);
+	request.controller?.error(error);
+}
+function abortPayloadRequest(request, reason) {
+	closeWithError(request, reason ?? new PayloadRequestCancelledError());
+}
+function flattenChildArrays(children) {
+	if (!children.some(Array.isArray)) return children;
+	const collected = [];
+	for (const child of children) if (Array.isArray(child)) for (const nested of flattenChildArrays(child)) collected.push(nested);
+	else collected.push(child);
+	return collected;
+}
+function invalidChildError$1(value) {
+	return /* @__PURE__ */ new Error(`Invalid Fig child in payload render: ${describeInvalidChild(value)}.`);
+}
+function throwIfAborted(signal) {
+	if (signal?.aborted) throw new PayloadRequestCancelledError();
+}
+//#endregion
+export { renderToPayloadStream };
+
+//# sourceMappingURL=payload.js.map