@sveltejs/kit 1.0.0-next.26 → 1.0.0-next.263

package/dist/node.js

@@ -0,0 +1,95 @@
+import { Readable } from 'stream';
+
+/** @type {import('@sveltejs/kit/node').GetRawBody} */
+function get_raw_body(req) {
+	return new Promise((fulfil, reject) => {
+		const h = req.headers;
+
+		if (!h['content-type']) {
+			return fulfil(null);
+		}
+
+		req.on('error', reject);
+
+		const length = Number(h['content-length']);
+
+		// https://github.com/jshttp/type-is/blob/c1f4388c71c8a01f79934e68f630ca4a15fffcd6/index.js#L81-L95
+		if (isNaN(length) && h['transfer-encoding'] == null) {
+			return fulfil(null);
+		}
+
+		let data = new Uint8Array(length || 0);
+
+		if (length > 0) {
+			let offset = 0;
+			req.on('data', (chunk) => {
+				const new_len = offset + Buffer.byteLength(chunk);
+
+				if (new_len > length) {
+					return reject({
+						status: 413,
+						reason: 'Exceeded "Content-Length" limit'
+					});
+				}
+
+				data.set(chunk, offset);
+				offset = new_len;
+			});
+		} else {
+			req.on('data', (chunk) => {
+				const new_data = new Uint8Array(data.length + chunk.length);
+				new_data.set(data, 0);
+				new_data.set(chunk, data.length);
+				data = new_data;
+			});
+		}
+
+		req.on('end', () => {
+			fulfil(data);
+		});
+	});
+}
+
+/** @type {import('@sveltejs/kit/node').GetRequest} */
+async function getRequest(base, req) {
+	let headers = /** @type {Record<string, string>} */ (req.headers);
+	if (req.httpVersionMajor === 2) {
+		// we need to strip out the HTTP/2 pseudo-headers because node-fetch's
+		// Request implementation doesn't like them
+		headers = Object.assign({}, headers);
+		delete headers[':method'];
+		delete headers[':path'];
+		delete headers[':authority'];
+		delete headers[':scheme'];
+	}
+	return new Request(base + req.url, {
+		method: req.method,
+		headers,
+		body: await get_raw_body(req) // TODO stream rather than buffer
+	});
+}
+
+/** @type {import('@sveltejs/kit/node').SetResponse} */
+async function setResponse(res, response) {
+	/** @type {import('../types/helper').ResponseHeaders} */
+	const headers = Object.fromEntries(response.headers);
+
+	if (response.headers.has('set-cookie')) {
+		// @ts-expect-error (headers.raw() is non-standard)
+		headers['set-cookie'] = response.headers.raw()['set-cookie'];
+	}
+
+	res.writeHead(response.status, headers);
+
+	if (response.body instanceof Readable) {
+		response.body.pipe(res);
+	} else {
+		if (response.body) {
+			res.write(await response.arrayBuffer());
+		}
+
+		res.end();
+	}
+}
+
+export { getRequest, setResponse };

package/package.json

@@ -1,55 +1,96 @@
 {
-	"name": "@sveltejs/kit",
-	"version": "1.0.0-next.26",
-	"dependencies": {
-		"cheap-watch": "^1.0.2",
-		"http-proxy": "^1.18.1",
-		"rollup": "^2.32.0",
-		"rollup-plugin-css-chunks": "^2.0.2",
-		"rollup-plugin-terser": "^7.0.2",
-		"sade": "^1.7.4",
-		"scorta": "^1.0.0",
-		"snowpack": "^3.0.10",
-		"source-map": "^0.7.3"
-	},
-	"devDependencies": {
-		"@sveltejs/app-utils": "*",
-		"@types/node": "^14.11.10",
-		"@types/rimraf": "^3.0.0",
-		"@types/sade": "^1.7.2",
-		"amphtml-validator": "^1.0.34",
-		"eslint": "^7.14.0",
-		"esm": "^3.2.25",
-		"estree-walker": "^2.0.1",
-		"is-reference": "^1.2.1",
-		"kleur": "^4.1.3",
-		"magic-string": "^0.25.7",
-		"meriyah": "^3.0.3",
-		"node-fetch": "^2.6.1",
-		"periscopic": "^2.0.2",
-		"port-authority": "^1.1.1",
-		"require-relative": "^0.8.7",
-		"rimraf": "^3.0.2",
-		"sirv": "^1.0.7",
-		"source-map-support": "^0.5.19",
-		"svelte": "^3.29.0",
-		"tiny-glob": "^0.2.8"
-	},
-	"bin": {
-		"svelte-kit": "svelte-kit"
-	},
-	"files": [
-		"assets",
-		"dist",
-		"client"
-	],
-	"scripts": {
-		"dev": "rollup -cw",
-		"build": "rollup -c",
-		"lint": "eslint --ignore-path .gitignore \"**/*.{ts,mjs,js,svelte}\" && npm run check-format",
-		"format": "prettier --write . --config ../../.prettierrc --ignore-path .gitignore",
-		"check-format": "prettier --check . --config ../../.prettierrc --ignore-path .gitignore",
-		"prepublishOnly": "npm run build",
-		"test": "uvu src \"(spec.js|test/index.js)\" -r esm"
-	}
-}
+  "name": "@sveltejs/kit",
+  "version": "1.0.0-next.263",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sveltejs/kit",
+    "directory": "packages/kit"
+  },
+  "license": "MIT",
+  "homepage": "https://kit.svelte.dev",
+  "type": "module",
+  "dependencies": {
+    "@sveltejs/vite-plugin-svelte": "^1.0.0-next.32",
+    "sade": "^1.7.4",
+    "vite": "^2.8.0"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.17.1",
+    "@rollup/plugin-replace": "^3.0.0",
+    "@types/amphtml-validator": "^1.0.1",
+    "@types/cookie": "^0.4.1",
+    "@types/marked": "^4.0.1",
+    "@types/mime": "^2.0.3",
+    "@types/node": "^16.11.11",
+    "@types/sade": "^1.7.3",
+    "amphtml-validator": "^1.0.35",
+    "cookie": "^0.4.1",
+    "cross-env": "^7.0.3",
+    "devalue": "^2.0.1",
+    "eslint": "^8.3.0",
+    "kleur": "^4.1.4",
+    "locate-character": "^2.0.5",
+    "marked": "^4.0.5",
+    "mime": "^3.0.0",
+    "node-fetch": "^3.1.0",
+    "port-authority": "^1.1.2",
+    "rollup": "^2.60.2",
+    "selfsigned": "^2.0.0",
+    "sirv": "^2.0.0",
+    "svelte": "^3.44.2",
+    "svelte-check": "^2.2.10",
+    "svelte-preprocess": "^4.9.8",
+    "svelte2tsx": "~0.5.0",
+    "tiny-glob": "^0.2.9",
+    "uvu": "^0.5.2"
+  },
+  "peerDependencies": {
+    "svelte": "^3.44.0"
+  },
+  "bin": {
+    "svelte-kit": "svelte-kit.js"
+  },
+  "files": [
+    "assets",
+    "dist",
+    "types",
+    "svelte-kit.js"
+  ],
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./types/index.d.ts"
+    },
+    "./node": {
+      "import": "./dist/node.js"
+    },
+    "./hooks": {
+      "import": "./dist/hooks.js"
+    },
+    "./install-fetch": {
+      "import": "./dist/install-fetch.js"
+    }
+  },
+  "types": "types/index.d.ts",
+  "engines": {
+    "node": ">=14.13"
+  },
+  "scripts": {
+    "build": "rollup -c && node scripts/cp.js src/runtime/components assets/components",
+    "dev": "rollup -cw",
+    "lint": "eslint --ignore-path .gitignore --ignore-pattern \"src/packaging/test/**\" \"{src,test}/**/*.{ts,mjs,js,svelte}\" && npm run check-format",
+    "check": "tsc && svelte-check --ignore test/prerendering,src/packaging/test",
+    "format": "npm run check-format -- --write",
+    "check-format": "prettier --check . --config ../../.prettierrc --ignore-path .gitignore",
+    "test": "npm run test:unit && npm run test:packaging && npm run test:prerendering && npm run test:integration",
+    "test:unit": "uvu src \"(spec\\.js|test[\\\\/]index\\.js)\" -i packaging",
+    "test:prerendering": "pnpm test:prerendering:basics",
+    "test:prerendering:basics": "cd test/prerendering/basics && pnpm test",
+    "test:packaging": "uvu src/packaging \"(spec\\.js|test[\\\\/]index\\.js)\"",
+    "test:integration": "pnpm test:integration:amp && pnpm test:integration:basics && pnpm test:integration:options && pnpm test:integration:options-2",
+    "test:integration:amp": "cd test/apps/amp && pnpm test",
+    "test:integration:basics": "cd test/apps/basics && pnpm test",
+    "test:integration:options": "cd test/apps/options && pnpm test",
+    "test:integration:options-2": "cd test/apps/options-2 && pnpm test"
+  }
+}

package/svelte-kit.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import './dist/cli.js';

package/types/ambient-modules.d.ts

@@ -0,0 +1,208 @@
+/* eslint-disable import/no-duplicates */
+
+declare namespace App {
+	interface Locals {}
+	interface Platform {}
+	interface Session {}
+	interface Stuff {}
+}
+
+declare module '$app/env' {
+	/**
+	 * Whether or not app is in AMP mode.
+	 */
+	export const amp: boolean;
+	/**
+	 * Whether the app is running in the browser or on the server.
+	 */
+	export const browser: boolean;
+	/**
+	 * `true` in development mode, `false` in production.
+	 */
+	export const dev: boolean;
+	/**
+	 * `true` when prerendering, `false` otherwise.
+	 */
+	export const prerendering: boolean;
+	/**
+	 * The Vite.js mode the app is running in. Configure in `config.kit.vite.mode`.
+	 * Vite.js loads the dotenv file associated with the provided mode, `.env.[mode]` or `.env.[mode].local`.
+	 * By default, `svelte-kit dev` runs with `mode=development` and `svelte-kit build` runs with `mode=production`.
+	 */
+	export const mode: string;
+}
+
+declare module '$app/navigation' {
+	/**
+	 * Disable SvelteKit's built-in scroll handling for the current navigation, in case you need to manually control the scroll position.
+	 * This is generally discouraged, since it breaks user expectations.
+	 */
+	export function disableScrollHandling(): void;
+	/**
+	 * Returns a Promise that resolves when SvelteKit navigates (or fails to navigate, in which case the promise rejects) to the specified href.
+	 *
+	 * @param href Where to navigate to
+	 * @param opts.replaceState If `true`, will replace the current `history` entry rather than creating a new one with `pushState`
+	 * @param opts.noscroll If `true`, the browser will maintain its scroll position rather than scrolling to the top of the page after navigation
+	 * @param opts.keepfocus If `true`, the currently focused element will retain focus after navigation. Otherwise, focus will be reset to the body
+	 * @param opts.state The state of the new/updated history entry
+	 */
+	export function goto(
+		href: string,
+		opts?: { replaceState?: boolean; noscroll?: boolean; keepfocus?: boolean; state?: any }
+	): Promise<any>;
+	/**
+	 * Returns a Promise that resolves when SvelteKit re-runs any current `load` functions that depend on `href`
+	 * @param href The invalidated resource
+	 */
+	export function invalidate(href: string): Promise<any>;
+	/**
+	 * Programmatically prefetches the given page, which means
+	 *  1. ensuring that the code for the page is loaded, and
+	 *  2. calling the page's load function with the appropriate options.
+	 *
+	 * This is the same behaviour that SvelteKit triggers when the user taps or mouses over an `<a>` element with `sveltekit:prefetch`.
+	 * If the next navigation is to `href`, the values returned from load will be used, making navigation instantaneous.
+	 * Returns a Promise that resolves when the prefetch is complete.
+	 *
+	 * @param href Page to prefetch
+	 */
+	export function prefetch(href: string): Promise<any>;
+	/**
+	 * Programmatically prefetches the code for routes that haven't yet been fetched.
+	 * Typically, you might call this to speed up subsequent navigation.
+	 *
+	 * If no argument is given, all routes will be fetched, otherwise you can specify routes by any matching pathname
+	 * such as `/about` (to match `src/routes/about.svelte`) or `/blog/*` (to match `src/routes/blog/[slug].svelte`).
+	 *
+	 * Unlike prefetch, this won't call preload for individual pages.
+	 * Returns a Promise that resolves when the routes have been prefetched.
+	 */
+	export function prefetchRoutes(routes?: string[]): Promise<any>;
+
+	/**
+	 * A navigation interceptor that triggers before we navigate to a new route.
+	 * This is helpful if we want to conditionally prevent a navigation from completing or lookup the upcoming url.
+	 */
+	export function beforeNavigate(
+		fn: ({ from, to, cancel }: { from: URL; to: URL | null; cancel: () => void }) => void
+	): any;
+
+	/**
+	 * A lifecycle function that runs when the page mounts, and also whenever SvelteKit navigates to a new URL but stays on this component.
+	 */
+	export function afterNavigate(fn: ({ from, to }: { from: URL | null; to: URL }) => void): any;
+}
+
+declare module '$app/paths' {
+	/**
+	 * A root-relative (i.e. begins with a `/`) string that matches `config.kit.paths.base` in your project configuration.
+	 */
+	export const base: string;
+	/**
+	 * A root-relative or absolute path that matches `config.kit.paths.assets` (after it has been resolved against base).
+	 */
+	export const assets: string;
+}
+
+declare module '$app/stores' {
+	import { Readable, Writable } from 'svelte/store';
+	type Navigating = { from: URL; to: URL };
+
+	/**
+	 * A convenience function around `getContext` that returns `{ navigating, page, session }`.
+	 * Most of the time, you won't need to use it.
+	 */
+	export function getStores(): {
+		navigating: typeof navigating;
+		page: typeof page;
+		session: Writable<App.Session>;
+		updated: typeof updated;
+	};
+	/**
+	 * A readable store whose value contains page data.
+	 */
+	export const page: Readable<{
+		url: URL;
+		params: Record<string, string>;
+		stuff: App.Stuff;
+		status: number;
+		error: Error | null;
+	}>;
+	/**
+	 * A readable store.
+	 * When navigating starts, its value is `{ from: URL, to: URL }`
+	 * When navigating finishes, its value reverts to `null`.
+	 */
+	export const navigating: Readable<Navigating | null>;
+	/**
+	 * A writable store whose initial value is whatever was returned from `getSession`.
+	 * It can be written to, but this will not cause changes to persist on the server — this is something you must implement yourself.
+	 */
+	export const session: Writable<App.Session>;
+	/**
+	 * A writable store indicating if the site was updated since the store was created.
+	 * It can be written to when custom logic is required to detect updates.
+	 */
+	export const updated: Readable<boolean> & { check: () => boolean };
+}
+
+declare module '$service-worker' {
+	/**
+	 * An array of URL strings representing the files generated by Vite, suitable for caching with `cache.addAll(build)`.
+	 * This is only available to service workers.
+	 */
+	export const build: string[];
+	/**
+	 * An array of URL strings representing the files in your static directory,
+	 * or whatever directory is specified by `config.kit.files.assets`.
+	 * This is only available to service workers.
+	 */
+	export const files: string[];
+	/**
+	 * The result of calling `Date.now()` at build time.
+	 * It's useful for generating unique cache names inside your service worker,
+	 * so that a later deployment of your app can invalidate old caches.
+	 * This is only available to service workers.
+	 */
+	export const timestamp: number;
+}
+
+declare module '@sveltejs/kit/hooks' {
+	import { Handle } from '@sveltejs/kit';
+
+	/**
+	 * Utility function that allows chaining `handle` functions in a
+	 * middleware-like manner.
+	 *
+	 * @param handlers The chain of `handle` functions
+	 */
+	export function sequence(...handlers: Handle[]): Handle;
+}
+
+declare module '@sveltejs/kit/node' {
+	import { IncomingMessage, ServerResponse } from 'http';
+
+	export interface GetRawBody {
+		(request: IncomingMessage): Promise<Uint8Array | null>;
+	}
+	export const getRawBody: GetRawBody;
+
+	export interface GetRequest {
+		(base: string, request: IncomingMessage): Promise<Request>;
+	}
+	export const getRequest: GetRequest;
+
+	export interface SetResponse {
+		(res: ServerResponse, response: Response): void;
+	}
+	export const setResponse: SetResponse;
+}
+
+declare module '@sveltejs/kit/install-fetch' {
+	import fetch, { Headers, Request, Response } from 'node-fetch';
+
+	export function __fetch_polyfill(): void;
+
+	export { fetch, Headers, Request, Response };
+}

package/types/app.d.ts

@@ -0,0 +1,35 @@
+import { PrerenderOptions, SSRNodeLoader, SSRRoute } from './internal';
+
+export interface RequestOptions<Platform = Record<string, any>> {
+	platform?: Platform;
+}
+
+export class App {
+	constructor(manifest: SSRManifest);
+	render(request: Request, options?: RequestOptions): Promise<Response>;
+}
+
+export class InternalApp extends App {
+	render(
+		request: Request,
+		options?: RequestOptions & {
+			prerender?: PrerenderOptions;
+		}
+	): Promise<Response>;
+}
+
+export interface SSRManifest {
+	appDir: string;
+	assets: Set<string>;
+	/** private fields */
+	_: {
+		mime: Record<string, string>;
+		entry: {
+			file: string;
+			js: string[];
+			css: string[];
+		};
+		nodes: SSRNodeLoader[];
+		routes: SSRRoute[];
+	};
+}

package/types/config.d.ts

@@ -0,0 +1,176 @@
+import { CompileOptions } from 'svelte/types/compiler/interfaces';
+import { UserConfig as ViteConfig } from 'vite';
+import { CspDirectives } from './csp';
+import { MaybePromise, RecursiveRequired } from './helper';
+import { HttpMethod, Logger, RouteSegment, TrailingSlash } from './internal';
+
+export interface RouteDefinition {
+	type: 'page' | 'endpoint';
+	pattern: RegExp;
+	segments: RouteSegment[];
+	methods: HttpMethod[];
+}
+
+export interface AdapterEntry {
+	/**
+	 * A string that uniquely identifies an HTTP service (e.g. serverless function) and is used for deduplication.
+	 * For example, `/foo/a-[b]` and `/foo/[c]` are different routes, but would both
+	 * be represented in a Netlify _redirects file as `/foo/:param`, so they share an ID
+	 */
+	id: string;
+
+	/**
+	 * A function that compares the candidate route with the current route to determine
+	 * if it should be treated as a fallback for the current route. For example, `/foo/[c]`
+	 * is a fallback for `/foo/a-[b]`, and `/[...catchall]` is a fallback for all routes
+	 */
+	filter: (route: RouteDefinition) => boolean;
+
+	/**
+	 * A function that is invoked once the entry has been created. This is where you
+	 * should write the function to the filesystem and generate redirect manifests.
+	 */
+	complete: (entry: {
+		generateManifest: (opts: { relativePath: string; format?: 'esm' | 'cjs' }) => string;
+	}) => void;
+}
+
+export interface Builder {
+	log: Logger;
+	rimraf(dir: string): void;
+	mkdirp(dir: string): void;
+
+	appDir: string;
+
+	/**
+	 * Create entry points that map to individual functions
+	 * @param fn A function that groups a set of routes into an entry point
+	 */
+	createEntries(fn: (route: RouteDefinition) => AdapterEntry): void;
+
+	generateManifest: (opts: { relativePath: string; format?: 'esm' | 'cjs' }) => string;
+
+	getBuildDirectory(name: string): string;
+	getClientDirectory(): string;
+	getServerDirectory(): string;
+	getStaticDirectory(): string;
+
+	/**
+	 * @param dest the destination folder to which files should be copied
+	 * @returns an array of paths corresponding to the files that have been created by the copy
+	 */
+	writeClient(dest: string): string[];
+	/**
+	 * @param dest the destination folder to which files should be copied
+	 * @returns an array of paths corresponding to the files that have been created by the copy
+	 */
+	writeServer(dest: string): string[];
+	/**
+	 * @param dest the destination folder to which files should be copied
+	 * @returns an array of paths corresponding to the files that have been created by the copy
+	 */
+	writeStatic(dest: string): string[];
+	/**
+	 * @param from the source file or folder
+	 * @param to the destination file or folder
+	 * @param opts.filter a function to determine whether a file or folder should be copied
+	 * @param opts.replace a map of strings to replace
+	 * @returns an array of paths corresponding to the files that have been created by the copy
+	 */
+	copy(
+		from: string,
+		to: string,
+		opts?: {
+			filter?: (basename: string) => boolean;
+			replace?: Record<string, string>;
+		}
+	): string[];
+
+	prerender(options: { all?: boolean; dest: string; fallback?: string }): Promise<{
+		paths: string[];
+	}>;
+}
+
+export interface Adapter {
+	name: string;
+	headers?: {
+		host?: string;
+		protocol?: string;
+	};
+	adapt(builder: Builder): Promise<void>;
+}
+
+export interface PrerenderErrorHandler {
+	(details: {
+		status: number;
+		path: string;
+		referrer: string | null;
+		referenceType: 'linked' | 'fetched';
+	}): void;
+}
+
+export type PrerenderOnErrorValue = 'fail' | 'continue' | PrerenderErrorHandler;
+
+export interface Config {
+	compilerOptions?: CompileOptions;
+	extensions?: string[];
+	kit?: {
+		adapter?: Adapter;
+		amp?: boolean;
+		appDir?: string;
+		browser?: {
+			hydrate?: boolean;
+			router?: boolean;
+		};
+		csp?: {
+			mode?: 'hash' | 'nonce' | 'auto';
+			directives?: CspDirectives;
+		};
+		files?: {
+			assets?: string;
+			hooks?: string;
+			lib?: string;
+			routes?: string;
+			serviceWorker?: string;
+			template?: string;
+		};
+		floc?: boolean;
+		inlineStyleThreshold?: number;
+		methodOverride?: {
+			parameter?: string;
+			allowed?: string[];
+		};
+		package?: {
+			dir?: string;
+			emitTypes?: boolean;
+			exports?(filepath: string): boolean;
+			files?(filepath: string): boolean;
+		};
+		paths?: {
+			assets?: string;
+			base?: string;
+		};
+		prerender?: {
+			concurrency?: number;
+			crawl?: boolean;
+			createIndexFiles?: boolean;
+			enabled?: boolean;
+			entries?: string[];
+			onError?: PrerenderOnErrorValue;
+		};
+		routes?: (filepath: string) => boolean;
+		serviceWorker?: {
+			register?: boolean;
+			files?: (filepath: string) => boolean;
+		};
+		trailingSlash?: TrailingSlash;
+		version?: {
+			name?: string;
+			pollInterval?: number;
+		};
+		vite?: ViteConfig | (() => MaybePromise<ViteConfig>);
+	};
+	preprocess?: any;
+}
+
+export type ValidatedConfig = RecursiveRequired<Config>;