@sveltejs/kit 1.0.0-next.391 → 1.0.0-next.394

package/dist/chunks/index3.js

@@ -0,0 +1,218 @@
+import { $ } from './index.js';
+import { r as rimraf, m as mkdirp, c as copy } from './filesystem.js';
+import { g as generate_manifest } from '../vite.js';
+import 'fs';
+import 'path';
+import 'url';
+import 'node:child_process';
+import 'node:fs';
+import 'node:path';
+import '@sveltejs/vite-plugin-svelte';
+import 'vite';
+import './sync.js';
+import './utils.js';
+import './write_tsconfig.js';
+import 'querystring';
+import '../node.js';
+import '../node/polyfills.js';
+import 'assert';
+import 'net';
+import 'http';
+import 'stream';
+import 'buffer';
+import 'util';
+import 'stream/web';
+import 'perf_hooks';
+import 'util/types';
+import 'events';
+import 'tls';
+import 'async_hooks';
+import 'console';
+import 'zlib';
+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 'crypto';
+import './error.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) && !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);
+		},
+
+		// TODO remove these methods for 1.0
+		// @ts-expect-error
+		writeStatic() {
+			throw new Error(
+				`writeStatic has been removed. Please ensure you are using the latest version of ${
+					config.kit.adapter.name || 'your adapter'
+				}`
+			);
+		},
+
+		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/sync.js

@@ -1,8 +1,9 @@
 import path__default from 'path';
 import fs__default from 'fs';
-import { $ } from './error.js';
+import { g as get_runtime_directory } from './utils.js';
+import { p as posixify, c as copy, r as rimraf } from './filesystem.js';
 import { fileURLToPath } from 'url';
-import { p as posixify, c as copy, a as write_if_changed, t as trim, r as rimraf, b as write, d as write_tsconfig } from './write_tsconfig.js';
+import { w as write_if_changed, t as trim, a as write, b as write_tsconfig } from './write_tsconfig.js';
 
 /**
  * @param typeMap [Object] Map of MIME type -> Array[extensions]
@@ -107,67 +108,6 @@ var other = {"application/prs.cww":["cww"],"application/vnd.1000minds.decision-m
 let Mime = Mime_1;
 var mime = new Mime(standard, other);
 
-/**
- * Get the prefix for the `runtime` directory, for use with import declarations
- * @param {import('types').ValidatedKitConfig} config
- */
-function get_runtime_prefix(config) {
-	{
-		return posixify_path(path__default.join(config.outDir, 'runtime'));
-	}
-}
-
-/**
- * Get the resolved path of the `runtime` directory
- * @param {import('types').ValidatedKitConfig} config
- */
-function get_runtime_directory(config) {
-	{
-		return path__default.join(config.outDir, 'runtime');
-	}
-}
-
-/** @param {string} str */
-function posixify_path(str) {
-	const parsed = path__default.parse(str);
-	return `/${parsed.dir.slice(parsed.root.length).split(path__default.sep).join('/')}/${parsed.base}`;
-}
-
-function noop() {}
-
-/** @param {{ verbose: boolean }} opts */
-function logger({ verbose }) {
-	/** @type {import('types').Logger} */
-	const log = (msg) => console.log(msg.replace(/^/gm, '  '));
-
-	/** @param {string} msg */
-	const err = (msg) => console.error(msg.replace(/^/gm, '  '));
-
-	log.success = (msg) => log($.green(`✔ ${msg}`));
-	log.error = (msg) => err($.bold().red(msg));
-	log.warn = (msg) => log($.bold().yellow(msg));
-
-	log.minor = verbose ? (msg) => log($.grey(msg)) : noop;
-	log.info = verbose ? log : noop;
-
-	return log;
-}
-
-/** @param {import('types').ManifestData} manifest_data */
-function get_mime_lookup(manifest_data) {
-	/** @type {Record<string, string>} */
-	const mime = {};
-
-	manifest_data.assets.forEach((asset) => {
-		if (asset.type) {
-			const ext = path__default.extname(asset.file);
-			mime[ext] = asset.type;
-		}
-	});
-
-	return mime;
-}
-
 const param_pattern = /^(\.\.\.)?(\w+)(?:=(\w+))?$/;
 
 /** @param {string} id */
@@ -1004,4 +944,4 @@ var sync = /*#__PURE__*/Object.freeze({
   all: all
 });
 
-export { get_runtime_prefix as a, get_mime_lookup as b, all as c, sync as d, get_runtime_directory as g, init as i, logger as l, parse_route_id as p, s, update as u };
+export { all as a, sync as b, init as i, parse_route_id as p, s, update as u };

package/dist/chunks/utils.js

@@ -0,0 +1,66 @@
+import path__default from 'path';
+import { $ } from './index.js';
+import 'url';
+
+/**
+ * Get the prefix for the `runtime` directory, for use with import declarations
+ * @param {import('types').ValidatedKitConfig} config
+ */
+function get_runtime_prefix(config) {
+	{
+		return posixify_path(path__default.join(config.outDir, 'runtime'));
+	}
+}
+
+/**
+ * Get the resolved path of the `runtime` directory
+ * @param {import('types').ValidatedKitConfig} config
+ */
+function get_runtime_directory(config) {
+	{
+		return path__default.join(config.outDir, 'runtime');
+	}
+}
+
+/** @param {string} str */
+function posixify_path(str) {
+	const parsed = path__default.parse(str);
+	return `/${parsed.dir.slice(parsed.root.length).split(path__default.sep).join('/')}/${parsed.base}`;
+}
+
+function noop() {}
+
+/** @param {{ verbose: boolean }} opts */
+function logger({ verbose }) {
+	/** @type {import('types').Logger} */
+	const log = (msg) => console.log(msg.replace(/^/gm, '  '));
+
+	/** @param {string} msg */
+	const err = (msg) => console.error(msg.replace(/^/gm, '  '));
+
+	log.success = (msg) => log($.green(`✔ ${msg}`));
+	log.error = (msg) => err($.bold().red(msg));
+	log.warn = (msg) => log($.bold().yellow(msg));
+
+	log.minor = verbose ? (msg) => log($.grey(msg)) : noop;
+	log.info = verbose ? log : noop;
+
+	return log;
+}
+
+/** @param {import('types').ManifestData} manifest_data */
+function get_mime_lookup(manifest_data) {
+	/** @type {Record<string, string>} */
+	const mime = {};
+
+	manifest_data.assets.forEach((asset) => {
+		if (asset.type) {
+			const ext = path__default.extname(asset.file);
+			mime[ext] = asset.type;
+		}
+	});
+
+	return mime;
+}
+
+export { get_runtime_prefix as a, get_mime_lookup as b, get_runtime_directory as g, logger as l };

package/dist/chunks/write_tsconfig.js

@@ -1,112 +1,7 @@
 import fs__default from 'fs';
 import path__default from 'path';
-import { $ } from './error.js';
-
-/** @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, '/');
-}
+import { $ } from './index.js';
+import { m as mkdirp, p as posixify } from './filesystem.js';
 
 /** @type {Map<string, string>} */
 const previous_contents = new Map();
@@ -271,4 +166,4 @@ function validate(config, cwd, out, user_file) {
 	}
 }
 
-export { write_if_changed as a, write as b, copy as c, write_tsconfig as d, mkdirp as m, posixify as p, rimraf as r, trim as t, walk as w };
+export { write as a, write_tsconfig as b, trim as t, write_if_changed as w };

package/dist/cli.js

@@ -1,6 +1,7 @@
 import fs__default from 'fs';
-import { l as load_config, $, c as coalesce_to_error } from './chunks/error.js';
+import { l as load_config, $ } from './chunks/index.js';
 import sade from 'sade';
+import { c as coalesce_to_error } from './chunks/error.js';
 import 'path';
 import 'url';
 
@@ -18,7 +19,7 @@ function handle_error(e) {
 	process.exit(1);
 }
 
-const prog = sade('svelte-kit').version('1.0.0-next.391');
+const prog = sade('svelte-kit').version('1.0.0-next.394');
 
 prog
 	.command('package')
@@ -27,7 +28,7 @@ prog
 	.action(async ({ watch }) => {
 		try {
 			const config = await load_config();
-			const packaging = await import('./chunks/index.js');
+			const packaging = await import('./chunks/index2.js');
 
 			await (watch ? packaging.watch(config) : packaging.build(config));
 		} catch (error) {
@@ -46,7 +47,7 @@ prog
 
 		try {
 			const config = await load_config();
-			const sync = await import('./chunks/sync.js').then(function (n) { return n.d; });
+			const sync = await import('./chunks/sync.js').then(function (n) { return n.b; });
 			sync.all(config);
 		} catch (error) {
 			handle_error(error);