@sveltejs/kit 2.57.1 → 2.59.0

package/src/runtime/client/ndjson.js

@@ -0,0 +1,42 @@
+/**
+ * Yields parsed JSON objects from a ReadableStream of newline-delimited JSON.
+ * Each yielded value is the raw `JSON.parse`'d object — callers handle deserialization.
+ * @param {ReadableStreamDefaultReader<Uint8Array>} reader
+ */
+export async function* read_ndjson(reader) {
+	let done = false;
+	let buffer = '';
+	const decoder = new TextDecoder();
+
+	while (true) {
+		let split = buffer.indexOf('\n');
+		while (split !== -1) {
+			const line = buffer.slice(0, split).trim();
+			buffer = buffer.slice(split + 1);
+
+			if (line) {
+				yield JSON.parse(line);
+			}
+
+			split = buffer.indexOf('\n');
+		}
+
+		if (done) {
+			const line = buffer.trim();
+			if (line) {
+				yield JSON.parse(line);
+			}
+			return;
+		}
+
+		const chunk = await reader.read();
+		done = chunk.done;
+		if (chunk.value) {
+			buffer += decoder.decode(chunk.value, { stream: true });
+		}
+
+		if (done) {
+			buffer += decoder.decode();
+		}
+	}
+}

package/src/runtime/client/remote-functions/command.svelte.js

@@ -8,7 +8,8 @@ import { stringify_remote_arg } from '../../shared.js';
 import {
 	get_remote_request_headers,
 	apply_refreshes,
-	categorize_updates
+	categorize_updates,
+	apply_reconnections
 } from './shared.svelte.js';
 
 /**
@@ -35,8 +36,8 @@ export function command(id) {
 		// Increment pending count when command starts
 		pending_count++;
 
-		// Noone should call commands during rendering but belts and braces.
-		// Do this here, after await Svelte' reactivity context is gone.
+		// No one should call commands during rendering, but this is belt and braces.
+		// Do this here, after Svelte's reactivity context is gone.
 		const headers = {
 			'Content-Type': 'application/json',
 			...get_remote_request_headers()
@@ -79,6 +80,10 @@ export function command(id) {
 						apply_refreshes(result.refreshes);
 					}
 
+					if (result.reconnects) {
+						apply_reconnections(result.reconnects);
+					}
+
 					return devalue.parse(result.result, app.decoders);
 				}
 			} finally {

package/src/runtime/client/remote-functions/form.svelte.js

@@ -7,7 +7,7 @@ import { DEV } from 'esm-env';
 import { HttpError } from '@sveltejs/kit/internal';
 import { app, query_responses, _goto, set_nearest_error_page, invalidateAll } from '../client.js';
 import { tick } from 'svelte';
-import { apply_refreshes, categorize_updates } from './shared.svelte.js';
+import { apply_refreshes, categorize_updates, apply_reconnections } from './shared.svelte.js';
 import { createAttachmentKey } from 'svelte/attachments';
 import {
 	convert_formdata,
@@ -156,7 +156,6 @@ export function form(id) {
 			}
 
 			try {
-				// eslint-disable-next-line @typescript-eslint/await-thenable -- `callback` is typed as returning `void` to allow returning e.g. `Promise<boolean>`
 				await callback({
 					form,
 					data,
@@ -228,27 +227,46 @@ export function form(id) {
 
 					// reset issues in case it's a redirect or error (but issues passed in that case)
 					raw_issues = [];
+					result = undefined;
 
 					if (form_result.type === 'result') {
 						({ issues: raw_issues = [], result } = devalue.parse(form_result.result, app.decoders));
 						const succeeded = raw_issues.length === 0;
 
 						if (succeeded) {
-							if (form_result.refreshes) {
-								apply_refreshes(form_result.refreshes);
-							} else {
+							if (refreshes === null && !form_result.refreshes && !form_result.reconnects) {
 								void invalidateAll();
+							} else {
+								if (form_result.refreshes) {
+									apply_refreshes(form_result.refreshes);
+								}
+								if (form_result.reconnects) {
+									apply_reconnections(form_result.reconnects);
+								}
 							}
 						}
 
 						return succeeded;
 					} else if (form_result.type === 'redirect') {
 						const stringified_refreshes = form_result.refreshes ?? '';
+						const stringified_reconnects = form_result.reconnects ?? '';
 						if (stringified_refreshes) {
 							apply_refreshes(stringified_refreshes);
 						}
+
+						if (stringified_reconnects) {
+							apply_reconnections(stringified_reconnects);
+						}
+
 						// Use internal version to allow redirects to external URLs
-						void _goto(form_result.location, { invalidateAll: !stringified_refreshes }, 0);
+						void _goto(
+							form_result.location,
+							{
+								invalidateAll:
+									refreshes === null && !stringified_refreshes && !stringified_reconnects
+							},
+							0
+						);
 						return true;
 					} else {
 						throw new HttpError(form_result.status ?? 500, form_result.error);

package/src/runtime/client/remote-functions/index.js

@@ -1,4 +1,6 @@
 export { command } from './command.svelte.js';
 export { form } from './form.svelte.js';
 export { prerender } from './prerender.svelte.js';
-export { query, query_batch } from './query.svelte.js';
+export { query } from './query.svelte.js';
+export { query_batch } from './query-batch.svelte.js';
+export { query_live } from './query-live.svelte.js';

package/src/runtime/client/remote-functions/query-batch.svelte.js

@@ -0,0 +1,105 @@
+/** @import { RemoteQueryFunction } from '@sveltejs/kit' */
+/** @import { RemoteFunctionResponse } from 'types' */
+import { app_dir, base } from '$app/paths/internal/client';
+import { app, goto } from '../client.js';
+import { get_remote_request_headers, QUERY_FUNCTION_ID } from './shared.svelte.js';
+import { QueryProxy } from './query.svelte.js';
+import * as devalue from 'devalue';
+import { HttpError, Redirect } from '@sveltejs/kit/internal';
+import { unfriendly_hydratable } from '../../shared.js';
+
+/**
+ * @param {string} id
+ * @returns {RemoteQueryFunction<any, any>}
+ */
+export function query_batch(id) {
+	/** @type {Map<string, Array<{resolve: (value: any) => void, reject: (error: any) => void}>>} */
+	let batching = new Map();
+
+	/** @type {RemoteQueryFunction<any, any>} */
+	const wrapper = (arg) => {
+		return new QueryProxy(id, arg, async (key, payload) => {
+			const serialized = await unfriendly_hydratable(key, () => {
+				return new Promise((resolve, reject) => {
+					// create_remote_function caches identical calls, but in case a refresh to the same query is called multiple times this function
+					// is invoked multiple times with the same payload, so we need to deduplicate here
+					const entry = batching.get(payload) ?? [];
+					entry.push({ resolve, reject });
+					batching.set(payload, entry);
+
+					if (batching.size > 1) return;
+
+					// Do this here, after await Svelte' reactivity context is gone.
+					// TODO is it possible to have batches of the same key
+					// but in different forks/async contexts and in the same macrotask?
+					// If so this would potentially be buggy
+					const headers = {
+						'Content-Type': 'application/json',
+						...get_remote_request_headers()
+					};
+
+					// Wait for the next macrotask - don't use microtask as Svelte runtime uses these to collect changes and flush them,
+					// and flushes could reveal more queries that should be batched.
+					setTimeout(async () => {
+						const batched = batching;
+						batching = new Map();
+
+						try {
+							const response = await fetch(`${base}/${app_dir}/remote/${id}`, {
+								method: 'POST',
+								body: JSON.stringify({
+									payloads: Array.from(batched.keys())
+								}),
+								headers
+							});
+
+							if (!response.ok) {
+								throw new Error('Failed to execute batch query');
+							}
+
+							const result = /** @type {RemoteFunctionResponse} */ (await response.json());
+							if (result.type === 'error') {
+								throw new HttpError(result.status ?? 500, result.error);
+							}
+
+							if (result.type === 'redirect') {
+								await goto(result.location);
+								throw new Redirect(307, result.location);
+							}
+
+							const results = devalue.parse(result.result, app.decoders);
+
+							// Resolve individual queries
+							// Maps guarantee insertion order so we can do it like this
+							let i = 0;
+
+							for (const resolvers of batched.values()) {
+								for (const { resolve, reject } of resolvers) {
+									if (results[i].type === 'error') {
+										reject(new HttpError(results[i].status, results[i].error));
+									} else {
+										resolve(results[i].data);
+									}
+								}
+								i++;
+							}
+						} catch (error) {
+							// Reject all queries in the batch
+							for (const resolver of batched.values()) {
+								for (const { reject } of resolver) {
+									reject(error);
+								}
+							}
+						}
+					}, 0);
+				});
+			});
+
+			return devalue.parse(serialized, app.decoders);
+		});
+	};
+
+	Object.defineProperty(wrapper, QUERY_FUNCTION_ID, { value: id });
+
+	return wrapper;
+}