@sveltejs/kit 1.0.0-next.21 → 1.0.0-next.210

package/package.json

@@ -1,55 +1,91 @@
 {
-	"name": "@sveltejs/kit",
-	"version": "1.0.0-next.21",
-	"dependencies": {
-		"@sveltejs/app-utils": "1.0.0-next.0",
-		"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.0-rc.1",
-		"source-map": "^0.7.3"
-	},
-	"devDependencies": {
-		"@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.210",
+  "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",
+    "cheap-watch": "^1.0.4",
+    "sade": "^1.7.4",
+    "vite": "^2.7.2"
+  },
+  "devDependencies": {
+    "@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",
+    "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": "^1.10.11",
+    "sirv": "^1.0.19",
+    "svelte": "^3.44.2",
+    "svelte-check": "^2.2.10",
+    "svelte2tsx": "~0.4.10",
+    "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"
+    },
+    "./ssr": {
+      "import": "./dist/ssr.js"
+    },
+    "./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",
+    "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 \"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:integration",
+    "test:unit": "uvu src \"(spec\\.js|test[\\\\/]index\\.js)\" -i packaging",
+    "test:packaging": "uvu src/packaging \"(spec\\.js|test[\\\\/]index\\.js)\"",
+    "test:integration": "uvu test test.js"
+  }
+}

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,181 @@
+/* eslint-disable import/no-duplicates */
+
+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' {
+	/**
+	 * 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>;
+}
+
+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<Session = any>(): {
+		navigating: Readable<Navigating | null>;
+		page: Readable<{
+			url: URL;
+			params: Record<string, string>;
+		}>;
+		session: Writable<Session>;
+	};
+	export const url: Readable<URL>;
+	/**
+	 * A readable store whose value contains page data.
+	 */
+	export const page: Readable<{
+		url: URL;
+		params: Record<string, string>;
+	}>;
+	/**
+	 * 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<any>;
+}
+
+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 } from 'http';
+	import { RawBody } from '@sveltejs/kit';
+
+	export interface GetRawBody {
+		(request: IncomingMessage): Promise<RawBody>;
+	}
+	export const getRawBody: GetRawBody;
+}
+
+declare module '@sveltejs/kit/ssr' {
+	import { IncomingRequest, Response } from '@sveltejs/kit';
+	// TODO import from public types, right now its heavily coupled with internal
+	type Options = import('@sveltejs/kit/types/internal').SSRRenderOptions;
+	type State = import('@sveltejs/kit/types/internal').SSRRenderState;
+
+	export interface Respond {
+		(incoming: IncomingRequest & { url: URL }, options: Options, state?: State): Promise<
+			Response | undefined
+		>;
+	}
+	export const respond: Respond;
+}
+
+declare module '@sveltejs/kit/install-fetch' {
+	import fetch, { Headers, Request, Response } from 'node-fetch';
+
+	export { fetch, Headers, Request, Response };
+}

package/types/app.d.ts

@@ -0,0 +1,45 @@
+import { ReadOnlyFormData, RequestHeaders } from './helper';
+import { ServerResponse } from './hooks';
+import { PrerenderOptions, SSRNodeLoader, SSRRoute } from './internal';
+
+export class App {
+	constructor(manifest: SSRManifest);
+	render(incoming: IncomingRequest): Promise<ServerResponse>;
+}
+
+export class InternalApp extends App {
+	render(
+		incoming: IncomingRequest,
+		options?: {
+			prerender: PrerenderOptions;
+		}
+	): Promise<ServerResponse>;
+}
+
+export type RawBody = null | Uint8Array;
+export type ParameterizedBody<Body = unknown> = Body extends FormData
+	? ReadOnlyFormData
+	: (string | RawBody | ReadOnlyFormData) & Body;
+
+export interface IncomingRequest {
+	url: string | URL;
+	method: string;
+	headers: RequestHeaders;
+	rawBody: RawBody;
+}
+
+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,163 @@
+import { UserConfig as ViteConfig } from 'vite';
+import { 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;
+
+	/**
+	 * 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?: any;
+	extensions?: string[];
+	kit?: {
+		adapter?: Adapter;
+		amp?: boolean;
+		appDir?: string;
+		files?: {
+			assets?: string;
+			hooks?: string;
+			lib?: string;
+			routes?: string;
+			serviceWorker?: string;
+			template?: string;
+		};
+		floc?: boolean;
+		headers?: {
+			host?: string;
+			protocol?: string;
+		};
+		host?: string;
+		hydrate?: boolean;
+		package?: {
+			dir?: string;
+			emitTypes?: boolean;
+			exports?(filepath: string): boolean;
+			files?(filepath: string): boolean;
+		};
+		paths?: {
+			assets?: string;
+			base?: string;
+		};
+		prerender?: {
+			concurrency?: number;
+			crawl?: boolean;
+			enabled?: boolean;
+			entries?: string[];
+			onError?: PrerenderOnErrorValue;
+		};
+		protocol?: string;
+		router?: boolean;
+		serviceWorker?: {
+			register?: boolean;
+			files?: (filepath: string) => boolean;
+		};
+		ssr?: boolean;
+		target?: string;
+		trailingSlash?: TrailingSlash;
+		vite?: ViteConfig | (() => ViteConfig);
+	};
+	preprocess?: any;
+}
+
+export type ValidatedConfig = RecursiveRequired<Config>;

package/types/endpoint.d.ts

@@ -0,0 +1,18 @@
+import { ServerRequest } from './hooks';
+import { JSONString, MaybePromise, ResponseHeaders } from './helper';
+
+type DefaultBody = JSONString | Uint8Array;
+
+export interface EndpointOutput<Body extends DefaultBody = DefaultBody> {
+	status?: number;
+	headers?: ResponseHeaders;
+	body?: Body;
+}
+
+export interface RequestHandler<
+	Locals = Record<string, any>,
+	Input = unknown,
+	Output extends DefaultBody = DefaultBody
+> {
+	(request: ServerRequest<Locals, Input>): MaybePromise<void | EndpointOutput<Output>>;
+}

package/types/helper.d.ts

@@ -0,0 +1,41 @@
+interface ReadOnlyFormData {
+	get(key: string): string;
+	getAll(key: string): string[];
+	has(key: string): boolean;
+	entries(): Generator<[string, string], void>;
+	keys(): Generator<string, void>;
+	values(): Generator<string, void>;
+	[Symbol.iterator](): Generator<[string, string], void>;
+}
+
+type ToJSON = { toJSON(...args: any[]): JSONValue };
+type JSONValue = Exclude<JSONString, ToJSON>;
+export type JSONString =
+	| string
+	| number
+	| boolean
+	| null
+	| ToJSON
+	| JSONString[]
+	| { [key: string]: JSONString };
+
+/** `string[]` is only for set-cookie, everything else must be type of `string` */
+export type ResponseHeaders = Record<string, string | string[]>;
+export type RequestHeaders = Record<string, string>;
+
+// Utility Types
+export type InferValue<T, Key extends keyof T, Default> = T extends Record<Key, infer Val>
+	? Val
+	: Default;
+export type MaybePromise<T> = T | Promise<T>;
+export type Rec<T = any> = Record<string, T>;
+export type RecursiveRequired<T> = {
+	// Recursive implementation of TypeScript's Required utility type.
+	// Will recursively continue until it reaches primitive or union
+	// with a Function in it, except those commented below
+	[K in keyof T]-?: Extract<T[K], Function> extends never // If it does not have a Function type
+		? RecursiveRequired<T[K]> // recursively continue through.
+		: K extends 'vite' // If it reaches the 'vite' key
+		? Extract<T[K], Function> // only take the Function type.
+		: T[K]; // Use the exact type for everything else
+};

package/types/hooks.d.ts

@@ -0,0 +1,48 @@
+import { ParameterizedBody, RawBody } from './app';
+import { MaybePromise, RequestHeaders, ResponseHeaders } from './helper';
+
+export type StrictBody = string | Uint8Array;
+
+export interface ServerRequest<Locals = Record<string, any>, Body = unknown> {
+	url: URL;
+	method: string;
+	headers: RequestHeaders;
+	rawBody: RawBody;
+	params: Record<string, string>;
+	body: ParameterizedBody<Body>;
+	locals: Locals;
+}
+
+export interface ServerResponse {
+	status: number;
+	headers: ResponseHeaders;
+	body?: StrictBody;
+}
+
+export interface GetSession<Locals = Record<string, any>, Body = unknown, Session = any> {
+	(request: ServerRequest<Locals, Body>): MaybePromise<Session>;
+}
+
+export interface Handle<Locals = Record<string, any>, Body = unknown> {
+	(input: {
+		request: ServerRequest<Locals, Body>;
+		resolve(request: ServerRequest<Locals, Body>): MaybePromise<ServerResponse>;
+	}): MaybePromise<ServerResponse>;
+}
+
+// internally, `resolve` could return `undefined`, so we differentiate InternalHandle
+// from the public Handle type
+export interface InternalHandle<Locals = Record<string, any>, Body = unknown> {
+	(input: {
+		request: ServerRequest<Locals, Body>;
+		resolve(request: ServerRequest<Locals, Body>): MaybePromise<ServerResponse | undefined>;
+	}): MaybePromise<ServerResponse | undefined>;
+}
+
+export interface HandleError<Locals = Record<string, any>, Body = unknown> {
+	(input: { error: Error & { frame?: string }; request: ServerRequest<Locals, Body> }): void;
+}
+
+export interface ExternalFetch {
+	(req: Request): Promise<Response>;
+}

package/types/index.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="svelte" />
+/// <reference types="vite/client" />
+
+import './ambient-modules';
+
+export { App, IncomingRequest, RawBody, SSRManifest } from './app';
+export { Adapter, Builder, Config, PrerenderErrorHandler, ValidatedConfig } from './config';
+export { EndpointOutput, RequestHandler } from './endpoint';
+export { ErrorLoad, ErrorLoadInput, Load, LoadInput, LoadOutput } from './page';
+export {
+	ExternalFetch,
+	GetSession,
+	Handle,
+	HandleError,
+	ServerRequest as Request,
+	ServerResponse as Response
+} from './hooks';