@sveltejs/kit 1.0.0-next.2 → 1.0.0-next.202

package/package.json

@@ -1,53 +1,91 @@
 {
-	"name": "@sveltejs/kit",
-	"version": "1.0.0-next.2",
-	"dependencies": {
-		"@sveltejs/app-utils": "1.0.0-next.0",
-		"cheap-watch": "^1.0.2",
-		"http-proxy": "^1.18.1",
-		"rollup": "^2.32.0",
-		"rollup-dependency-tree": "0.0.14",
-		"rollup-plugin-css-chunks": "^1.2.8",
-		"rollup-plugin-terser": "^7.0.2",
-		"sade": "^1.7.4",
-		"scorta": "^1.0.0",
-		"snowpack": "^2.17.0"
-	},
-	"devDependencies": {
-		"@types/node": "^14.11.10",
-		"@types/rimraf": "^3.0.0",
-		"@types/sade": "^1.7.2",
-		"eslint": "^7.14.0",
-		"esm": "^3.2.25",
-		"estree-walker": "^2.0.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-pattern node_modules/ --ignore-pattern dist/ --ignore-pattern assets/ \"**/*.{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.202",
+  "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.30",
+    "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,173 @@
+/* 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';
+	import { Page } from '@sveltejs/kit';
+	type Navigating = { from: Page; to: Page };
+
+	/**
+	 * 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<Page>;
+		session: Writable<Session>;
+	};
+	/**
+	 * A readable store whose value reflects the object passed to load functions.
+	 */
+	export const page: Readable<Page>;
+	/**
+	 * A readable store.
+	 * When navigating starts, its value is `{ from, to }`, where from and to both mirror the page store value.
+	 * 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, options: Options, state?: State): Promise<Response>;
+	}
+	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,21 @@
+import { ReadOnlyFormData, RequestHeaders } from './helper';
+import { ServerResponse } from './hooks';
+
+export interface App {
+	init(): void;
+	render(incoming: IncomingRequest): Promise<ServerResponse>;
+}
+
+export type RawBody = null | Uint8Array;
+export type ParameterizedBody<Body = unknown> = Body extends FormData
+	? ReadOnlyFormData
+	: (string | RawBody | ReadOnlyFormData) & Body;
+
+export interface IncomingRequest {
+	method: string;
+	host: string;
+	path: string;
+	query: URLSearchParams;
+	headers: RequestHeaders;
+	rawBody: RawBody;
+}

package/types/config.d.ts

@@ -0,0 +1,96 @@
+import { UserConfig as ViteConfig } from 'vite';
+import { RecursiveRequired } from './helper';
+import { Logger, TrailingSlash } from './internal';
+
+export interface AdapterUtils {
+	log: Logger;
+	rimraf(dir: string): void;
+	mkdirp(dir: string): void;
+	/**
+	 * @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
+	 */
+	copy_client_files(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
+	 */
+	copy_server_files(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
+	 */
+	copy_static_files(dest: string): string[];
+	/**
+	 * @param from the source folder from which files should be copied
+	 * @param to 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
+	 */
+	copy(from: string, to: string, filter?: (basename: string) => boolean): string[];
+	prerender(options: { all?: boolean; dest: string; fallback?: string }): Promise<void>;
+}
+
+export interface Adapter {
+	name: string;
+	adapt(context: { utils: AdapterUtils; config: ValidatedConfig }): 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;
+		host?: string;
+		hostHeader?: string;
+		hydrate?: boolean;
+		package?: {
+			dir?: string;
+			emitTypes?: boolean;
+			exports?(filepath: string): boolean;
+			files?(filepath: string): boolean;
+		};
+		paths?: {
+			assets?: string;
+			base?: string;
+		};
+		prerender?: {
+			crawl?: boolean;
+			enabled?: boolean;
+			entries?: string[];
+			onError?: PrerenderOnErrorValue;
+		};
+		router?: boolean;
+		serviceWorker?: {
+			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,36 @@
+import { IncomingRequest, ParameterizedBody } from './app';
+import { MaybePromise, ResponseHeaders } from './helper';
+
+export type StrictBody = string | Uint8Array;
+
+export interface ServerRequest<Locals = Record<string, any>, Body = unknown>
+	extends IncomingRequest {
+	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>;
+}
+
+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 } from './app';
+export { Adapter, AdapterUtils, Config, PrerenderErrorHandler, ValidatedConfig } from './config';
+export { EndpointOutput, RequestHandler } from './endpoint';
+export { ErrorLoad, ErrorLoadInput, Load, LoadInput, LoadOutput, Page } from './page';
+export {
+	ExternalFetch,
+	GetSession,
+	Handle,
+	HandleError,
+	ServerRequest as Request,
+	ServerResponse as Response
+} from './hooks';