@sveltejs/kit 1.0.0-next.352 → 1.0.0-next.355

package/dist/chunks/filesystem.js

@@ -1,110 +0,0 @@
-import fs__default from 'fs';
-import path__default from 'path';
-
-/** @param {string} dir */
-function mkdirp(dir) {
-	try {
-		fs__default.mkdirSync(dir, { recursive: true });
-	} catch (/** @type {any} */ e) {
-		if (e.code === 'EEXIST') return;
-		throw e;
-	}
-}
-
-/** @param {string} path */
-function rimraf(path) {
-	fs__default.rmSync(path, { force: true, recursive: true });
-}
-
-/**
- * @param {string} source
- * @param {string} target
- * @param {{
- *   filter?: (basename: string) => boolean;
- *   replace?: Record<string, string>;
- * }} opts
- */
-function copy(source, target, opts = {}) {
-	if (!fs__default.existsSync(source)) return [];
-
-	/** @type {string[]} */
-	const files = [];
-
-	const prefix = posixify(target) + '/';
-
-	const regex = opts.replace
-		? new RegExp(`\\b(${Object.keys(opts.replace).join('|')})\\b`, 'g')
-		: null;
-
-	/**
-	 * @param {string} from
-	 * @param {string} to
-	 */
-	function go(from, to) {
-		if (opts.filter && !opts.filter(path__default.basename(from))) return;
-
-		const stats = fs__default.statSync(from);
-
-		if (stats.isDirectory()) {
-			fs__default.readdirSync(from).forEach((file) => {
-				go(path__default.join(from, file), path__default.join(to, file));
-			});
-		} else {
-			mkdirp(path__default.dirname(to));
-
-			if (opts.replace) {
-				const data = fs__default.readFileSync(from, 'utf-8');
-				fs__default.writeFileSync(
-					to,
-					data.replace(
-						/** @type {RegExp} */ (regex),
-						(match, key) => /** @type {Record<string, string>} */ (opts.replace)[key]
-					)
-				);
-			} else {
-				fs__default.copyFileSync(from, to);
-			}
-
-			files.push(to === target ? posixify(path__default.basename(to)) : posixify(to).replace(prefix, ''));
-		}
-	}
-
-	go(source, target);
-
-	return files;
-}
-
-/**
- * Get a list of all files in a directory
- * @param {string} cwd - the directory to walk
- * @param {boolean} [dirs] - whether to include directories in the result
- */
-function walk(cwd, dirs = false) {
-	/** @type {string[]} */
-	const all_files = [];
-
-	/** @param {string} dir */
-	function walk_dir(dir) {
-		const files = fs__default.readdirSync(path__default.join(cwd, dir));
-
-		for (const file of files) {
-			const joined = path__default.join(dir, file);
-			const stats = fs__default.statSync(path__default.join(cwd, joined));
-			if (stats.isDirectory()) {
-				if (dirs) all_files.push(joined);
-				walk_dir(joined);
-			} else {
-				all_files.push(joined);
-			}
-		}
-	}
-
-	return walk_dir(''), all_files;
-}
-
-/** @param {string} str */
-function posixify(str) {
-	return str.replace(/\\/g, '/');
-}
-
-export { copy as c, mkdirp as m, posixify as p, rimraf as r, walk as w };

package/dist/chunks/index3.js

@@ -1,183 +0,0 @@
-import { $ } from '../cli.js';
-import { r as rimraf, m as mkdirp, c as copy } from './filesystem.js';
-import { g as generate_manifest } from './index2.js';
-import 'chokidar';
-import 'fs';
-import 'path';
-import 'sade';
-import 'vite';
-import 'url';
-import 'os';
-import './misc.js';
-
-/**
- * Creates the Builder which is passed to adapters for building the application.
- * @param {{
- *   config: import('types').ValidatedConfig;
- *   build_data: import('types').BuildData;
- *   prerendered: import('types').Prerendered;
- *   log: import('types').Logger;
- * }} opts
- * @returns {import('types').Builder}
- */
-function create_builder({ config, build_data, prerendered, log }) {
-	/** @type {Set<string>} */
-	const prerendered_paths = new Set(prerendered.paths);
-
-	/** @param {import('types').RouteData} route */
-	// TODO routes should come pre-filtered
-	function not_prerendered(route) {
-		if (route.type === 'page' && route.path) {
-			return !prerendered_paths.has(route.path);
-		}
-
-		return true;
-	}
-
-	return {
-		log,
-		rimraf,
-		mkdirp,
-		copy,
-
-		config,
-		prerendered,
-
-		async createEntries(fn) {
-			const { routes } = build_data.manifest_data;
-
-			/** @type {import('types').RouteDefinition[]} */
-			const facades = routes.map((route) => ({
-				id: route.id,
-				type: route.type,
-				segments: route.id.split('/').map((segment) => ({
-					dynamic: segment.includes('['),
-					rest: segment.includes('[...'),
-					content: segment
-				})),
-				pattern: route.pattern,
-				methods: route.type === 'page' ? ['get'] : build_data.server.methods[route.file]
-			}));
-
-			const seen = new Set();
-
-			for (let i = 0; i < routes.length; i += 1) {
-				const route = routes[i];
-				const { id, filter, complete } = fn(facades[i]);
-
-				if (seen.has(id)) continue;
-				seen.add(id);
-
-				const group = [route];
-
-				// figure out which lower priority routes should be considered fallbacks
-				for (let j = i + 1; j < routes.length; j += 1) {
-					if (filter(facades[j])) {
-						group.push(routes[j]);
-					}
-				}
-
-				const filtered = new Set(group.filter(not_prerendered));
-
-				// heuristic: if /foo/[bar] is included, /foo/[bar].json should
-				// also be included, since the page likely needs the endpoint
-				filtered.forEach((route) => {
-					if (route.type === 'page') {
-						const endpoint = routes.find((candidate) => candidate.id === route.id + '.json');
-
-						if (endpoint) {
-							filtered.add(endpoint);
-						}
-					}
-				});
-
-				if (filtered.size > 0) {
-					await complete({
-						generateManifest: ({ relativePath, format }) =>
-							generate_manifest({
-								build_data,
-								relative_path: relativePath,
-								routes: Array.from(filtered),
-								format
-							})
-					});
-				}
-			}
-		},
-
-		generateManifest: ({ relativePath, format }) => {
-			return generate_manifest({
-				build_data,
-				relative_path: relativePath,
-				routes: build_data.manifest_data.routes.filter(not_prerendered),
-				format
-			});
-		},
-
-		getBuildDirectory(name) {
-			return `${config.kit.outDir}/${name}`;
-		},
-
-		getClientDirectory() {
-			return `${config.kit.outDir}/output/client`;
-		},
-
-		getServerDirectory() {
-			return `${config.kit.outDir}/output/server`;
-		},
-
-		getStaticDirectory() {
-			return config.kit.files.assets;
-		},
-
-		writeClient(dest) {
-			return copy(`${config.kit.outDir}/output/client`, dest);
-		},
-
-		writePrerendered(dest, { fallback } = {}) {
-			const source = `${config.kit.outDir}/output/prerendered`;
-			const files = [...copy(`${source}/pages`, dest), ...copy(`${source}/dependencies`, dest)];
-
-			if (fallback) {
-				files.push(fallback);
-				copy(`${source}/fallback.html`, `${dest}/${fallback}`);
-			}
-
-			return files;
-		},
-
-		writeServer(dest) {
-			return copy(`${config.kit.outDir}/output/server`, dest);
-		},
-
-		writeStatic(dest) {
-			return copy(config.kit.files.assets, dest);
-		},
-
-		// @ts-expect-error
-		async prerender() {
-			throw new Error(
-				'builder.prerender() has been removed. Prerendering now takes place in the build phase — see builder.prerender and builder.writePrerendered'
-			);
-		}
-	};
-}
-
-/**
- * @param {import('types').ValidatedConfig} config
- * @param {import('types').BuildData} build_data
- * @param {import('types').Prerendered} prerendered
- * @param {{ log: import('types').Logger }} opts
- */
-async function adapt(config, build_data, prerendered, { log }) {
-	const { name, adapt } = config.kit.adapter;
-
-	console.log($.bold().cyan(`\n> Using ${name}`));
-
-	const builder = create_builder({ config, build_data, prerendered, log });
-	await adapt(builder);
-
-	log.success('done');
-}
-
-export { adapt };

package/dist/chunks/index4.js

@@ -1,215 +0,0 @@
-import fs__default from 'fs';
-import { join } from 'path';
-import { S as SVELTE_KIT_ASSETS, s as sirv } from './constants.js';
-import { pathToFileURL } from 'url';
-import { getRequest, setResponse } from '../node.js';
-import { installPolyfills } from '../node/polyfills.js';
-import { d as load_config } from '../cli.js';
-import 'querystring';
-import 'stream';
-import 'node:http';
-import 'node:https';
-import 'node:zlib';
-import 'node:stream';
-import 'node:buffer';
-import 'node:util';
-import 'node:url';
-import 'node:net';
-import 'node:fs';
-import 'node:path';
-import 'crypto';
-import 'chokidar';
-import 'sade';
-import 'vite';
-import 'os';
-
-/** @typedef {import('http').IncomingMessage} Req */
-/** @typedef {import('http').ServerResponse} Res */
-/** @typedef {(req: Req, res: Res, next: () => void) => void} Handler */
-
-/** @type {import('types').ValidatedConfig} */
-let config;
-
-/** @type {boolean} */
-let https;
-
-/** @type {import('vite').Plugin} */
-const sveltekit_plugin = {
-	name: 'vite-plugin-svelte-kit',
-	async config(vite_config) {
-		// defaults
-		vite_config.preview = vite_config.preview || {};
-		vite_config.preview.strictPort = vite_config.preview.strictPort ?? true;
-
-		config = await load_config();
-	},
-	async configResolved(vite_config) {
-		https = !!vite_config.preview.https;
-	},
-	async configurePreviewServer(vite) {
-		installPolyfills();
-
-		const { paths } = config.kit;
-		const base = paths.base;
-		const assets = paths.assets ? SVELTE_KIT_ASSETS : paths.base;
-
-		const etag = `"${Date.now()}"`;
-
-		const index_file = join(config.kit.outDir, 'output/server/index.js');
-		const manifest_file = join(config.kit.outDir, 'output/server/manifest.js');
-
-		/** @type {import('types').ServerModule} */
-		const { Server, override } = await import(pathToFileURL(index_file).href);
-		const { manifest } = await import(pathToFileURL(manifest_file).href);
-
-		override({
-			paths: { base, assets },
-			prerendering: false,
-			protocol: https ? 'https' : 'http',
-			read: (file) => fs__default.readFileSync(join(config.kit.files.assets, file))
-		});
-
-		const server = new Server(manifest);
-
-		return () => {
-			// files in `static`
-			vite.middlewares.use(scoped(assets, mutable(config.kit.files.assets)));
-
-			// immutable generated client assets
-			vite.middlewares.use(
-				scoped(
-					assets,
-					sirv(join(config.kit.outDir, 'output/client'), {
-						setHeaders: (res, pathname) => {
-							// only apply to build directory, not e.g. version.json
-							if (pathname.startsWith(`/${config.kit.appDir}/immutable`)) {
-								res.setHeader('cache-control', 'public,max-age=31536000,immutable');
-							}
-						}
-					})
-				)
-			);
-
-			vite.middlewares.use((req, res, next) => {
-				const original_url = /** @type {string} */ (req.url);
-				const { pathname } = new URL(original_url, 'http://dummy');
-
-				if (pathname.startsWith(base)) {
-					next();
-				} else {
-					res.statusCode = 404;
-					res.end(`Not found (did you mean ${base + pathname}?)`);
-				}
-			});
-
-			// prerendered dependencies
-			vite.middlewares.use(
-				scoped(base, mutable(join(config.kit.outDir, 'output/prerendered/dependencies')))
-			);
-
-			// prerendered pages (we can't just use sirv because we need to
-			// preserve the correct trailingSlash behaviour)
-			vite.middlewares.use(
-				scoped(base, (req, res, next) => {
-					let if_none_match_value = req.headers['if-none-match'];
-
-					if (if_none_match_value?.startsWith('W/"')) {
-						if_none_match_value = if_none_match_value.substring(2);
-					}
-
-					if (if_none_match_value === etag) {
-						res.statusCode = 304;
-						res.end();
-						return;
-					}
-
-					const { pathname } = new URL(/** @type {string} */ (req.url), 'http://dummy');
-
-					// only treat this as a page if it doesn't include an extension
-					if (pathname === '/' || /\/[^./]+\/?$/.test(pathname)) {
-						const file = join(
-							config.kit.outDir,
-							'output/prerendered/pages' +
-								pathname +
-								(pathname.endsWith('/') ? 'index.html' : '.html')
-						);
-
-						if (fs__default.existsSync(file)) {
-							res.writeHead(200, {
-								'content-type': 'text/html',
-								etag
-							});
-
-							fs__default.createReadStream(file).pipe(res);
-							return;
-						}
-					}
-
-					next();
-				})
-			);
-
-			// SSR
-			vite.middlewares.use(async (req, res) => {
-				const protocol = https ? 'https' : 'http';
-				const host = req.headers['host'];
-
-				let request;
-
-				try {
-					request = await getRequest(`${protocol}://${host}`, req);
-				} catch (/** @type {any} */ err) {
-					res.statusCode = err.status || 400;
-					return res.end(err.reason || 'Invalid request body');
-				}
-
-				setResponse(
-					res,
-					await server.respond(request, {
-						getClientAddress: () => {
-							const { remoteAddress } = req.socket;
-							if (remoteAddress) return remoteAddress;
-							throw new Error('Could not determine clientAddress');
-						}
-					})
-				);
-			});
-		};
-	}
-};
-
-/**
- * @param {string} dir
- * @returns {Handler}
- */
-const mutable = (dir) =>
-	fs__default.existsSync(dir)
-		? sirv(dir, {
-				etag: true,
-				maxAge: 0
-		  })
-		: (req, res, next) => next();
-
-/**
- * @param {string} scope
- * @param {Handler} handler
- * @returns {Handler}
- */
-function scoped(scope, handler) {
-	if (scope === '') return handler;
-
-	return (req, res, next) => {
-		if (req.url?.startsWith(scope)) {
-			const original_url = req.url;
-			req.url = req.url.slice(scope.length);
-			handler(req, res, () => {
-				req.url = original_url;
-				next();
-			});
-		} else {
-			next();
-		}
-	};
-}
-
-export { sveltekit_plugin };