@sveltejs/kit 1.0.0-next.43 → 1.0.0-next.430

package/src/runtime/client/fetcher.js

@@ -0,0 +1,60 @@
+import { hash } from '../hash.js';
+
+let loading = 0;
+
+export const native_fetch = window.fetch;
+
+export function lock_fetch() {
+	loading += 1;
+}
+
+export function unlock_fetch() {
+	loading -= 1;
+}
+
+if (import.meta.env.DEV) {
+	let can_inspect_stack_trace = false;
+
+	const check_stack_trace = async () => {
+		const stack = /** @type {string} */ (new Error().stack);
+		can_inspect_stack_trace = stack.includes('check_stack_trace');
+	};
+
+	check_stack_trace();
+
+	window.fetch = (input, init) => {
+		const url = input instanceof Request ? input.url : input.toString();
+		const stack = /** @type {string} */ (new Error().stack);
+
+		const heuristic = can_inspect_stack_trace ? stack.includes('load_node') : loading;
+		if (heuristic) {
+			console.warn(
+				`Loading ${url} using \`window.fetch\`. For best results, use the \`fetch\` that is passed to your \`load\` function: https://kit.svelte.dev/docs/load#input-fetch`
+			);
+		}
+
+		return native_fetch(input, init);
+	};
+}
+
+/**
+ * @param {RequestInfo} resource
+ * @param {RequestInit} [opts]
+ */
+export function initial_fetch(resource, opts) {
+	const url = JSON.stringify(typeof resource === 'string' ? resource : resource.url);
+
+	let selector = `script[sveltekit\\:data-type="data"][sveltekit\\:data-url=${url}]`;
+
+	if (opts && typeof opts.body === 'string') {
+		selector += `[sveltekit\\:data-body="${hash(opts.body)}"]`;
+	}
+
+	const script = document.querySelector(selector);
+	if (script && script.textContent) {
+		const { body, ...init } = JSON.parse(script.textContent);
+		return Promise.resolve(new Response(body, init));
+	}
+
+	return native_fetch(resource, opts);
+}

package/src/runtime/client/parse.js

@@ -0,0 +1,36 @@
+import { exec, parse_route_id } from '../../utils/routing.js';
+
+/**
+ * @param {import('types').CSRPageNodeLoader[]} nodes
+ * @param {Record<string, [number[], number[], number, 1?]>} dictionary
+ * @param {Record<string, (param: string) => boolean>} matchers
+ * @returns {import('types').CSRRoute[]}
+ */
+export function parse(nodes, dictionary, matchers) {
+	return Object.entries(dictionary).map(([id, [errors, layouts, leaf, uses_server_data]]) => {
+		const { pattern, names, types } = parse_route_id(id);
+
+		const route = {
+			id,
+			/** @param {string} path */
+			exec: (path) => {
+				const match = pattern.exec(path);
+				if (match) return exec(match, names, types, matchers);
+			},
+			errors: errors.map((n) => nodes[n]),
+			layouts: layouts.map((n) => nodes[n]),
+			leaf: nodes[leaf],
+			uses_server_data: !!uses_server_data
+		};
+
+		// bit of a hack, but ensures that layout/error node lists are the same
+		// length, without which the wrong data will be applied if the route
+		// manifest looks like `[[a, b], [c,], d]`
+		route.errors.length = route.layouts.length = Math.max(
+			route.errors.length,
+			route.layouts.length
+		);
+
+		return route;
+	});
+}

package/src/runtime/client/singletons.js

@@ -0,0 +1,21 @@
+import { writable } from 'svelte/store';
+import { create_updated_store, notifiable_store } from './utils.js';
+
+/** @type {import('./types').Client} */
+export let client;
+
+/**
+ * @param {{
+ *   client: import('./types').Client;
+ * }} opts
+ */
+export function init(opts) {
+	client = opts.client;
+}
+
+export const stores = {
+	url: notifiable_store({}),
+	page: notifiable_store({}),
+	navigating: writable(/** @type {import('types').Navigation | null} */ (null)),
+	updated: create_updated_store()
+};

package/src/runtime/client/start.js

@@ -0,0 +1,46 @@
+import { create_client } from './client.js';
+import { init } from './singletons.js';
+import { set_paths } from '../paths.js';
+
+export { set_public_env } from '../env-public.js';
+
+/**
+ * @param {{
+ *   paths: {
+ *     assets: string;
+ *     base: string;
+ *   },
+ *   target: Element;
+ *   route: boolean;
+ *   spa: boolean;
+ *   trailing_slash: import('types').TrailingSlash;
+ *   hydrate: {
+ *     status: number;
+ *     error: Error | (import('../server/page/types').SerializedHttpError);
+ *     node_ids: number[];
+ *     params: Record<string, string>;
+ *     routeId: string | null;
+ *   };
+ * }} opts
+ */
+export async function start({ paths, target, route, spa, trailing_slash, hydrate }) {
+	const client = create_client({
+		target,
+		base: paths.base,
+		trailing_slash
+	});
+
+	init({ client });
+	set_paths(paths);
+
+	if (hydrate) {
+		await client._hydrate(hydrate);
+	}
+
+	if (route) {
+		if (spa) client.goto(location.href, { replaceState: true });
+		client._start_router();
+	}
+
+	dispatchEvent(new CustomEvent('sveltekit:start'));
+}

package/src/runtime/client/types.d.ts

@@ -0,0 +1,105 @@
+import {
+	afterNavigate,
+	beforeNavigate,
+	goto,
+	invalidate,
+	prefetch,
+	prefetchRoutes
+} from '$app/navigation';
+import { CSRPageNode, CSRRoute } from 'types';
+import { HttpError } from '../../index/private.js';
+import { SerializedHttpError } from '../server/page/types.js';
+
+export interface Client {
+	// public API, exposed via $app/navigation
+	after_navigate: typeof afterNavigate;
+	before_navigate: typeof beforeNavigate;
+	disable_scroll_handling: () => void;
+	goto: typeof goto;
+	invalidate: typeof invalidate;
+	prefetch: typeof prefetch;
+	prefetch_routes: typeof prefetchRoutes;
+
+	// private API
+	_hydrate: (opts: {
+		status: number;
+		error: Error | SerializedHttpError;
+		node_ids: number[];
+		params: Record<string, string>;
+		routeId: string | null;
+	}) => Promise<void>;
+	_start_router: () => void;
+}
+
+export type NavigationIntent = {
+	/**
+	 * `url.pathname + url.search`
+	 */
+	id: string;
+	/**
+	 * The route parameters
+	 */
+	params: Record<string, string>;
+	/**
+	 * The route that matches `path`
+	 */
+	route: CSRRoute;
+	/**
+	 * The destination URL
+	 */
+	url: URL;
+};
+
+export type NavigationResult = NavigationRedirect | NavigationFinished;
+
+export type NavigationRedirect = {
+	type: 'redirect';
+	location: string;
+};
+
+export type NavigationFinished = {
+	type: 'loaded';
+	state: NavigationState;
+	props: Record<string, any>;
+};
+
+export type BranchNode = {
+	node: CSRPageNode;
+	data: Record<string, any> | null;
+	uses: {
+		params: Set<string>;
+		url: boolean; // TODO make more granular?
+		dependencies: Set<string>;
+		parent: boolean;
+	};
+};
+
+export type NavigationState = {
+	branch: Array<BranchNode | undefined>;
+	error: HttpError | Error | null;
+	params: Record<string, string>;
+	session_id: number;
+	url: URL;
+};
+
+export type ServerDataPayload = ServerDataRedirected | ServerDataLoaded;
+
+export interface ServerDataRedirected {
+	type: 'redirect';
+	location: string;
+}
+
+export interface ServerDataLoaded {
+	type: 'data';
+	nodes: Array<{
+		data?: Record<string, any> | null; // TODO or `-1` to indicate 'reuse cached data'?
+		status?: number;
+		message?: string;
+		error?: {
+			name: string;
+			message: string;
+			stack: string;
+			[key: string]: any;
+		};
+	}>;
+}

package/src/runtime/client/utils.js

@@ -0,0 +1,113 @@
+import { writable } from 'svelte/store';
+import { assets } from '../paths.js';
+
+/* global __SVELTEKIT_APP_VERSION__, __SVELTEKIT_APP_VERSION_FILE__, __SVELTEKIT_APP_VERSION_POLL_INTERVAL__ */
+
+/** @param {HTMLDocument} doc */
+export function get_base_uri(doc) {
+	let baseURI = doc.baseURI;
+
+	if (!baseURI) {
+		const baseTags = doc.getElementsByTagName('base');
+		baseURI = baseTags.length ? baseTags[0].href : doc.URL;
+	}
+
+	return baseURI;
+}
+
+export function scroll_state() {
+	return {
+		x: pageXOffset,
+		y: pageYOffset
+	};
+}
+
+/** @param {Event} event */
+export function find_anchor(event) {
+	const node = event
+		.composedPath()
+		.find((e) => e instanceof Node && e.nodeName.toUpperCase() === 'A'); // SVG <a> elements have a lowercase name
+	return /** @type {HTMLAnchorElement | SVGAElement | undefined} */ (node);
+}
+
+/** @param {HTMLAnchorElement | SVGAElement} node */
+export function get_href(node) {
+	return node instanceof SVGAElement
+		? new URL(node.href.baseVal, document.baseURI)
+		: new URL(node.href);
+}
+
+/** @param {any} value */
+export function notifiable_store(value) {
+	const store = writable(value);
+	let ready = true;
+
+	function notify() {
+		ready = true;
+		store.update((val) => val);
+	}
+
+	/** @param {any} new_value */
+	function set(new_value) {
+		ready = false;
+		store.set(new_value);
+	}
+
+	/** @param {(value: any) => void} run */
+	function subscribe(run) {
+		/** @type {any} */
+		let old_value;
+		return store.subscribe((new_value) => {
+			if (old_value === undefined || (ready && new_value !== old_value)) {
+				run((old_value = new_value));
+			}
+		});
+	}
+
+	return { notify, set, subscribe };
+}
+
+export function create_updated_store() {
+	const { set, subscribe } = writable(false);
+
+	const interval = __SVELTEKIT_APP_VERSION_POLL_INTERVAL__;
+
+	/** @type {NodeJS.Timeout} */
+	let timeout;
+
+	async function check() {
+		if (import.meta.env.DEV || import.meta.env.SSR) return false;
+
+		clearTimeout(timeout);
+
+		if (interval) timeout = setTimeout(check, interval);
+
+		const res = await fetch(`${assets}/${__SVELTEKIT_APP_VERSION_FILE__}`, {
+			headers: {
+				pragma: 'no-cache',
+				'cache-control': 'no-cache'
+			}
+		});
+
+		if (res.ok) {
+			const { version } = await res.json();
+			const updated = version !== __SVELTEKIT_APP_VERSION__;
+
+			if (updated) {
+				set(true);
+				clearTimeout(timeout);
+			}
+
+			return updated;
+		} else {
+			throw new Error(`Version check failed: ${res.status}`);
+		}
+	}
+
+	if (interval) timeout = setTimeout(check, interval);
+
+	return {
+		subscribe,
+		check
+	};
+}

package/src/runtime/components/error.svelte

@@ -0,0 +1,16 @@
+<script>
+	import { page } from '$app/stores';
+</script>
+
+<h1>{$page.status}</h1>
+
+<pre>{$page.error.message}</pre>
+
+<!-- TODO figure out what to do with frames/stacktraces in prod -->
+<!-- frame is populated by Svelte in its CompileError and is a Rollup/Vite convention -->
+{#if $page.error.frame}
+	<pre>{$page.error.frame}</pre>
+{/if}
+{#if $page.error.stack}
+	<pre>{$page.error.stack}</pre>
+{/if}

package/src/runtime/env/dynamic/private.js

@@ -0,0 +1 @@
+export { env } from '../../env-private.js';

package/src/runtime/env/dynamic/public.js

@@ -0,0 +1 @@
+export { env } from '../../env-public.js';

package/src/runtime/env-private.js

@@ -0,0 +1,7 @@
+/** @type {App.PrivateEnv} */
+export let env = {};
+
+/** @type {(environment: Record<string, string>) => void} */
+export function set_private_env(environment) {
+	env = environment;
+}

package/src/runtime/env-public.js

@@ -0,0 +1,7 @@
+/** @type {App.PublicEnv} */
+export let env = {};
+
+/** @type {(environment: Record<string, string>) => void} */
+export function set_public_env(environment) {
+	env = environment;
+}

package/src/runtime/env.js

@@ -0,0 +1,6 @@
+export let prerendering = false;
+
+/** @param {boolean} value */
+export function set_prerendering(value) {
+	prerendering = value;
+}

package/src/runtime/hash.js

@@ -0,0 +1,16 @@
+/**
+ * Hash using djb2
+ * @param {import('types').StrictBody} value
+ */
+export function hash(value) {
+	let hash = 5381;
+	let i = value.length;
+
+	if (typeof value === 'string') {
+		while (i) hash = (hash * 33) ^ value.charCodeAt(--i);
+	} else {
+		while (i) hash = (hash * 33) ^ value[--i];
+	}
+
+	return (hash >>> 0).toString(36);
+}

package/src/runtime/paths.js

@@ -0,0 +1,11 @@
+/** @type {string} */
+export let base = '';
+
+/** @type {string} */
+export let assets = '';
+
+/** @param {{ base: string, assets: string }} paths */
+export function set_paths(paths) {
+	base = paths.base;
+	assets = paths.assets || base;
+}

package/src/runtime/server/endpoint.js

@@ -0,0 +1,58 @@
+import { HttpError, Redirect } from '../../index/private.js';
+import { check_method_names, method_not_allowed } from './utils.js';
+
+/**
+ * @param {import('types').RequestEvent} event
+ * @param {import('types').SSREndpoint} route
+ * @returns {Promise<Response>}
+ */
+export async function render_endpoint(event, route) {
+	const method = /** @type {import('types').HttpMethod} */ (event.request.method);
+
+	const mod = await route.load();
+
+	// TODO: Remove for 1.0
+	check_method_names(mod);
+
+	let handler = mod[method];
+
+	if (!handler && method === 'HEAD') {
+		handler = mod.GET;
+	}
+
+	if (!handler) {
+		if (event.request.headers.get('x-sveltekit-load')) {
+			// TODO would be nice to avoid these requests altogether,
+			// by noting whether or not page endpoints export `get`
+			return new Response(undefined, { status: 204 });
+		}
+
+		return method_not_allowed(mod, method);
+	}
+
+	try {
+		const response = await handler(
+			/** @type {import('types').RequestEvent<Record<string, any>>} */ (event)
+		);
+
+		if (!(response instanceof Response)) {
+			return new Response(
+				`Invalid response from route ${event.url.pathname}: handler should return a Response object`,
+				{ status: 500 }
+			);
+		}
+
+		return response;
+	} catch (error) {
+		if (error instanceof HttpError) {
+			return new Response(error.message, { status: error.status });
+		} else if (error instanceof Redirect) {
+			return new Response(undefined, {
+				status: error.status,
+				headers: { Location: error.location }
+			});
+		} else {
+			throw error;
+		}
+	}
+}