@sveltejs/kit 3.0.0-next.0 → 3.0.0-next.10

package/src/runtime/client/entry.js

@@ -1,3 +1,24 @@
-// we expose this as a separate entry point (rather than treating client.js as the entry point)
-// so that everything other than `start`/`load_css` can be treeshaken
-export { start, load_css } from './client.js';
+/* in development or if `bundleStrategy` is 'split', this file is used as the entry point */
+
+import { set_payload } from './payload.js';
+
+/** @type {Promise<typeof import('./client-entry.js')>} */
+let client;
+
+/** @param {import('types').SvelteKitPayload} payload */
+export function init(payload) {
+	set_payload(payload);
+	// Importing the client after setting the payload ensures that modules such as
+	// `$app/paths` can read it during initialization.
+	client ??= import('./client-entry.js');
+}
+
+/** @param {Parameters<import('./client-entry.js').start>} args */
+export async function start(...args) {
+	return (await client).start(...args);
+}
+
+/** @param {Parameters<import('./client-entry.js').load_css>} args */
+export async function load_css(...args) {
+	return (await client).load_css(...args);
+}

package/src/runtime/client/fetcher.js

@@ -94,8 +94,6 @@ export function initial_fetch(resource, opts) {
 		script.remove(); // In case multiple script tags match the same selector
 		let { body, ...init } = JSON.parse(script.textContent);
 
-		const ttl = script.getAttribute('data-ttl');
-		if (ttl) cache.set(selector, { body, init, ttl: 1000 * Number(ttl) });
 		const b64 = script.getAttribute('data-b64');
 		if (b64 !== null) {
 			// Can't use native_fetch('data:...;base64,${body}')
@@ -103,6 +101,9 @@ export function initial_fetch(resource, opts) {
 			body = base64_decode(body);
 		}
 
+		const ttl = script.getAttribute('data-ttl');
+		if (ttl) cache.set(selector, { body, init, ttl: 1000 * Number(ttl) });
+
 		return Promise.resolve(new Response(body, init));
 	}
 

package/src/runtime/client/ndjson.js

@@ -1,42 +1,15 @@
+import { read_stream } from './stream.js';
+
 /**
  * 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();
+	for await (const block of read_stream(reader, '\n')) {
+		const line = block.trim();
+		if (line) {
+			yield JSON.parse(line);
 		}
 	}
 }

package/src/runtime/client/payload.js

@@ -0,0 +1,17 @@
+/** @import {SvelteKitPayload} from 'types'; */
+
+/**
+ * Code inside the SvelteKit client runtime should only use this, not the global,
+ * so that the file hashes stay stable between rebuilds as long as the SvelteKit runtime doesn't change
+ */
+export let payload = __SVELTEKIT_PAYLOAD__ ?? /** @type {SvelteKitPayload} */ ({});
+
+/** @param {SvelteKitPayload} value */
+export function set_payload(value) {
+	payload = value;
+}
+
+// this makes Vite inject its dev client code as this module's first dependency
+// so that global constant replacements are done before any other module evaluates.
+// For build, it's inert.
+import.meta.hot;

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

@@ -1,8 +1,10 @@
+/** @import { Query } from './query/instance.svelte.js' */
+/** @import { LiveQuery } from './query-live/instance.svelte.js' */
 import { tick } from 'svelte';
 import { once } from '../../../utils/functions.js';
 
 /**
- * @template R
+ * @template [R=Query<any> | LiveQuery<any>]
  * @typedef {object} CacheEntry
  * @property {number} proxy_count The number of live proxy instances referencing this
  *   entry. The entry is eligible for eviction when this hits zero.

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

@@ -1,16 +1,8 @@
 /** @import { RemoteCommand, RemoteQueryUpdate } from '@sveltejs/kit' */
-/** @import { RemoteFunctionResponse } from 'types' */
 import { app_dir, base } from '$app/paths/internal/client';
-import * as devalue from 'devalue';
-import { HttpError } from '@sveltejs/kit/internal';
 import { app } from '../client.js';
-import { stringify_remote_arg } from '../../shared.js';
-import {
-	get_remote_request_headers,
-	apply_refreshes,
-	categorize_updates,
-	apply_reconnections
-} from './shared.svelte.js';
+import { stringify_command_arg } from '../../shared.js';
+import { get_remote_request_headers, categorize_updates, remote_request } from './shared.svelte.js';
 
 /**
  * Client-version of the `command` function from `$app/server`.
@@ -53,39 +45,22 @@ export function command(id) {
 					throw updates_error;
 				}
 
-				const response = await fetch(`${base}/${app_dir}/remote/${id}`, {
+				const response = await remote_request(`${base}/${app_dir}/remote/${id}`, {
 					method: 'POST',
 					body: JSON.stringify({
-						payload: stringify_remote_arg(arg, app.hooks.transport, false),
+						payload: await stringify_command_arg(arg, app.hooks.transport),
 						refreshes: Array.from(refreshes ?? [])
 					}),
 					headers
 				});
 
-				if (!response.ok) {
-					// We only end up here in case of a network error or if the server has an internal error
-					// (which shouldn't happen because we handle errors on the server and always send a 200 response)
-					throw new Error('Failed to execute remote function');
-				}
-
-				const result = /** @type {RemoteFunctionResponse} */ (await response.json());
-				if (result.type === 'redirect') {
+				if (response.redirect) {
 					throw new Error(
 						'Redirects are not allowed in commands. Return a result instead and use goto on the client'
 					);
-				} else if (result.type === 'error') {
-					throw new HttpError(result.status ?? 500, result.error);
-				} else {
-					if (result.refreshes) {
-						apply_refreshes(result.refreshes);
-					}
-
-					if (result.reconnects) {
-						apply_reconnections(result.reconnects);
-					}
-
-					return devalue.parse(result.result, app.decoders);
 				}
+
+				return response._;
 			} finally {
 				overrides?.forEach((fn) => fn());