@sveltejs/kit 1.0.0-next.31 → 1.0.0-next.310

package/dist/node.js

@@ -0,0 +1,94 @@
+import { Readable } from 'stream';
+
+/** @param {import('http').IncomingMessage} req */
+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) {
+	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,93 @@
 {
-	"name": "@sveltejs/kit",
-	"version": "1.0.0-next.31",
-	"dependencies": {
-		"cheap-watch": "^1.0.3",
-		"http-proxy": "^1.18.1",
-		"rollup": "^2.38.3",
-		"rollup-plugin-css-chunks": "^2.0.2",
-		"rollup-plugin-terser": "^7.0.2",
-		"sade": "^1.7.4",
-		"scorta": "^1.0.0",
-		"snowpack": "^3.0.11",
-		"source-map": "^0.7.3"
-	},
-	"devDependencies": {
-		"@sveltejs/app-utils": "1.0.0-next.0",
-		"@types/node": "^14.14.22",
-		"@types/rimraf": "^3.0.0",
-		"@types/sade": "^1.7.2",
-		"amphtml-validator": "^1.0.34",
-		"eslint": "^7.19.0",
-		"esm": "^3.2.25",
-		"estree-walker": "^2.0.2",
-		"is-reference": "^1.2.1",
-		"kleur": "^4.1.4",
-		"magic-string": "^0.25.7",
-		"meriyah": "^3.1.6",
-		"node-fetch": "^2.6.1",
-		"periscopic": "^2.0.3",
-		"port-authority": "^1.1.2",
-		"require-relative": "^0.8.7",
-		"rimraf": "^3.0.2",
-		"sirv": "^1.0.11",
-		"source-map-support": "^0.5.19",
-		"svelte": "^3.32.1",
-		"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.310",
+  "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.9.0"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.20.2",
+    "@rollup/plugin-replace": "^4.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 && npm run types",
+    "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",
+    "check:all": "tsc && pnpm run -r check --filter ./",
+    "format": "npm run check-format -- --write",
+    "check-format": "prettier --check . --config ../../.prettierrc --ignore-path .gitignore",
+    "test": "npm run test:unit && npm run test:typings && npm run test:packaging",
+    "test:all": "pnpm run -r test --workspace-concurrency 1 --filter ./",
+    "test:unit": "uvu src \"(spec\\.js|test[\\\\/]index\\.js)\" -i packaging",
+    "test:typings": "tsc --project test/typings",
+    "test:packaging": "uvu src/packaging \"(spec\\.js|test[\\\\/]index\\.js)\"",
+    "types": "node scripts/extract-types.js"
+  }
+}

package/svelte-kit.js

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

package/types/ambient.d.ts

@@ -0,0 +1,298 @@
+/**
+ * It's possible to tell SvelteKit how to type objects inside your app by declaring the `App` namespace. By default, a new project will have a file called `src/app.d.ts` containing the following:
+ *
+ * ```ts
+ * /// <reference types="@sveltejs/kit" />
+ *
+ * declare namespace App {
+ * 	interface Locals {}
+ *
+ * 	interface Platform {}
+ *
+ * 	interface Session {}
+ *
+ * 	interface Stuff {}
+ * }
+ * ```
+ *
+ * By populating these interfaces, you will gain type safety when using `event.locals`, `event.platform`, `session` and `stuff`:
+ */
+declare namespace App {
+	/**
+	 * The interface that defines `event.locals`, which can be accessed in [hooks](/docs/hooks) (`handle`, `handleError` and `getSession`) and [endpoints](/docs/routing#endpoints).
+	 */
+	export interface Locals {}
+
+	/**
+	 * If your adapter provides [platform-specific context](/docs/adapters#supported-environments-platform-specific-context) via `event.platform`, you can specify it here.
+	 */
+	export interface Platform {}
+
+	/**
+	 * The interface that defines `session`, both as an argument to [`load`](/docs/loading) functions and the value of the [session store](/docs/modules#$app-stores).
+	 */
+	export interface Session {}
+
+	/**
+	 * The interface that defines `stuff`, as input or output to [`load`](/docs/loading) or as the value of the `stuff` property of the [page store](/docs/modules#$app-stores).
+	 */
+	export interface Stuff {}
+}
+
+/**
+ * ```ts
+ * import { amp, browser, dev, mode, prerendering } from '$app/env';
+ * ```
+ */
+declare module '$app/env' {
+	/**
+	 * Whether or not the app is running in [AMP mode](/docs/seo#manual-setup-amp).
+	 */
+	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;
+}
+
+/**
+ * ```ts
+ * import {
+ * 	afterNavigate,
+ * 	beforeNavigate,
+ * 	disableScrollHandling,
+ * 	goto,
+ * 	invalidate,
+ * 	prefetch,
+ * 	prefetchRoutes
+ * } from '$app/navigation';
+ * ```
+ */
+declare module '$app/navigation' {
+	/**
+	 * If called when the page is being updated following a navigation (in `onMount` or an action, for example), this disables SvelteKit's built-in scroll handling.
+	 * 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<void>;
+	/**
+	 * Causes any `load` functions belonging to the currently active page to re-run if they `fetch` the resource in question. Returns a `Promise` that resolves when the page is subsequently updated.
+	 * @param href The invalidated resource
+	 */
+	export function invalidate(href: string): Promise<void>;
+	/**
+	 * 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<void>;
+	/**
+	 * 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 load for individual pages.
+	 * Returns a Promise that resolves when the routes have been prefetched.
+	 */
+	export function prefetchRoutes(routes?: string[]): Promise<void>;
+
+	/**
+	 * A navigation interceptor that triggers before we navigate to a new URL (internal or external) whether by clicking a link, calling `goto`, or using the browser back/forward controls.
+	 * This is helpful if we want to conditionally prevent a navigation from completing or lookup the upcoming url.
+	 */
+	export function beforeNavigate(
+		fn: (navigation: { from: URL; to: URL | null; cancel: () => void }) => void
+	): void;
+
+	/**
+	 * 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: (navigation: { from: URL | null; to: URL }) => void): void;
+}
+
+/**
+ * ```ts
+ * import { base, assets } from '$app/paths';
+ * ```
+ */
+declare module '$app/paths' {
+	/**
+	 * A string that matches [`config.kit.paths.base`](/docs/configuration#paths). It must begin, but not end, with a `/`.
+	 */
+	export const base: `/${string}`;
+	/**
+	 * An absolute path that matches [`config.kit.paths.assets`](/docs/configuration#paths).
+	 *
+	 * > If a value for `config.kit.paths.assets` is specified, it will be replaced with `'/_svelte_kit_assets'` during [`svelte-kit dev`](/docs/cli#svelte-kit-dev) or [`svelte-kit preview`](/docs/cli#svelte-kit-preview), since the assets don't yet live at their eventual URL.
+	 */
+	export const assets: `https://${string}` | `http://${string}`;
+}
+
+/**
+ * ```ts
+ * import { getStores, navigating, page, session, updated } from '$app/stores';
+ * ```
+ *
+ * Stores are _contextual_ — they are added to the [context](https://svelte.dev/tutorial/context-api) of your root component. This means that `session` and `page` are unique to each request on the server, rather than shared between multiple requests handled by the same server simultaneously, which is what makes it safe to include user-specific data in `session`.
+ *
+ * Because of that, you must subscribe to the stores during component initialization (which happens automatically if you reference the store value, e.g. as `$page`, in a component) before you can use them.
+ */
+declare module '$app/stores' {
+	import { Readable, Writable } from 'svelte/store';
+	import { Navigation, Page } from '@sveltejs/kit';
+
+	/**
+	 * A convenience function around `getContext`. Must be called during component initialization.
+	 * Only use this if you need to defer store subscription until after the component has mounted, for some reason.
+	 */
+	export function getStores(): {
+		navigating: typeof navigating;
+		page: typeof page;
+		session: typeof session;
+		updated: typeof updated;
+	};
+
+	/**
+	 * A readable store whose value contains page data.
+	 */
+	export const page: Readable<Page>;
+	/**
+	 * 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<Navigation | null>;
+	/**
+	 * A writable store whose initial value is whatever was returned from [`getSession`](/docs/hooks#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 readable store whose initial value is `false`. If [`version.pollInterval`](/docs/configuration#version) is a non-zero value, SvelteKit will poll for new versions of the app and update the store value to `true` when it detects one. `updated.check()` will force an immediate check, regardless of polling.
+	 */
+	export const updated: Readable<boolean> & { check: () => boolean };
+}
+
+/**
+ * ```ts
+ * import { build, files, prerendered, version } from '$service-worker';
+ * ```
+ *
+ * This module is only available to [service workers](/docs/service-workers).
+ */
+declare module '$service-worker' {
+	/**
+	 * An array of URL strings representing the files generated by Vite, suitable for caching with `cache.addAll(build)`.
+	 */
+	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`. You can customize which files are included from `static` directory using [`config.kit.serviceWorker.files`](/docs/configuration)
+	 */
+	export const files: string[];
+	/**
+	 * An array of pathnames corresponding to prerendered pages and endpoints.
+	 */
+	export const prerendered: string[];
+	/**
+	 * See [`config.kit.version`](/docs/configuration#version). It's useful for generating unique cache names inside your service worker, so that a later deployment of your app can invalidate old caches.
+	 */
+	export const version: string;
+}
+
+declare module '@sveltejs/kit/hooks' {
+	import { Handle } from '@sveltejs/kit';
+
+	/**
+	 * A helper function for sequencing multiple `handle` calls in a middleware-like manner.
+	 *
+	 * ```js
+	 * /// file: src/hooks.js
+	 * import { sequence } from '@sveltejs/kit/hooks';
+	 *
+	 * /** @type {import('@sveltejs/kit').Handle} *\/
+	 * async function first({ event, resolve }) {
+	 * 	console.log('first pre-processing');
+	 * 	const result = await resolve(event);
+	 * 	console.log('first post-processing');
+	 * 	return result;
+	 * }
+	 *
+	 * /** @type {import('@sveltejs/kit').Handle} *\/
+	 * async function second({ event, resolve }) {
+	 * 	console.log('second pre-processing');
+	 * 	const result = await resolve(event);
+	 * 	console.log('second post-processing');
+	 * 	return result;
+	 * }
+	 *
+	 * export const handle = sequence(first, second);
+	 * ```
+	 *
+	 * The example above would print:
+	 *
+	 * ```
+	 * first pre-processing
+	 * second pre-processing
+	 * second post-processing
+	 * first post-processing
+	 * ```
+	 *
+	 * @param handlers The chain of `handle` functions
+	 */
+	export function sequence(...handlers: Handle[]): Handle;
+}
+
+/**
+ * A polyfill for `fetch` and its related interfaces, used by adapters for environments that don't provide a native implementation.
+ */
+declare module '@sveltejs/kit/install-fetch' {
+	/**
+	 * Make `fetch`, `Headers`, `Request` and `Response` available as globals, via `node-fetch`
+	 */
+	export function installFetch(): void;
+}
+
+/**
+ * Utilities used by adapters for Node-like environments.
+ */
+declare module '@sveltejs/kit/node' {
+	export function getRequest(
+		base: string,
+		request: import('http').IncomingMessage
+	): Promise<Request>;
+	export function setResponse(res: import('http').ServerResponse, response: Response): void;
+}