@sveltejs/kit 1.0.0-next.41 → 1.0.0-next.410

package/src/packaging/typescript.js

@@ -0,0 +1,150 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { createRequire } from 'module';
+import { posixify, mkdirp, rimraf, walk } from '../utils/filesystem.js';
+import { resolve_lib_alias, write } from './utils.js';
+
+/**
+ * @param {import('types').ValidatedConfig} config
+ * @param {string} cwd
+ * @param {import('./types').File[]} files
+ */
+export async function emit_dts(config, cwd, files) {
+	const tmp = `${config.kit.outDir}/package/types`;
+	rimraf(tmp);
+	mkdirp(tmp);
+
+	const require = createRequire(import.meta.url);
+	const emit = await try_load_svelte2tsx();
+	await emit({
+		libRoot: config.kit.files.lib,
+		svelteShimsPath: require.resolve('svelte2tsx/svelte-shims.d.ts'),
+		declarationDir: path.relative(cwd, tmp)
+	});
+
+	const handwritten = new Set();
+	const excluded = new Set();
+
+	// remove excluded files, and files that conflict with hand-written .d.ts
+	for (const file of files) {
+		if (file.name.endsWith('.d.ts')) {
+			handwritten.add(file.name);
+		}
+
+		if (!file.is_included) {
+			excluded.add(file.base + '.d.ts');
+			excluded.add(file.base + '.d.mts');
+			excluded.add(file.base + '.d.cts');
+		}
+	}
+
+	// resolve $lib alias (TODO others), copy into package dir
+	for (const file of walk(tmp)) {
+		const normalized = posixify(file);
+
+		if (handwritten.has(normalized)) {
+			console.warn(`Using $lib/${normalized} instead of generated .d.ts file`);
+		}
+
+		// don't overwrite hand-written .d.ts files
+		if (excluded.has(normalized)) continue;
+
+		const source = fs.readFileSync(path.join(tmp, normalized), 'utf8');
+		write(
+			path.join(config.kit.package.dir, normalized),
+			resolve_lib_alias(normalized, source, config)
+		);
+	}
+}
+
+async function try_load_svelte2tsx() {
+	const svelte2tsx = await load();
+	const emit_dts = svelte2tsx.emitDts;
+	if (!emit_dts) {
+		throw new Error(
+			'You need to install svelte2tsx >=0.4.1 if you want to generate type definitions'
+		);
+	}
+	return emit_dts;
+
+	async function load() {
+		try {
+			return await import('svelte2tsx');
+		} catch (e) {
+			throw new Error(
+				'You need svelte2tsx and typescript if you want to generate type definitions. Install it through your package manager, or disable generation which is highly discouraged. See https://kit.svelte.dev/docs/packaging'
+			);
+		}
+	}
+}
+
+/**
+ * @param {string} filename
+ * @param {string} source
+ */
+export async function transpile_ts(filename, source) {
+	const ts = await try_load_ts();
+	return ts.transpileModule(source, {
+		compilerOptions: load_tsconfig(filename, ts),
+		fileName: filename
+	}).outputText;
+}
+
+async function try_load_ts() {
+	try {
+		return (await import('typescript')).default;
+	} catch (e) {
+		throw new Error(
+			'You need to install TypeScript if you want to transpile TypeScript files and/or generate type definitions'
+		);
+	}
+}
+
+/**
+ * @param {string} filename
+ * @param {import('typescript')} ts
+ */
+function load_tsconfig(filename, ts) {
+	let config_filename;
+
+	// ts.findConfigFile is broken (it will favour a distant tsconfig
+	// over a near jsconfig, and then only when you call it twice)
+	// so we implement it ourselves
+	let dir = filename;
+	while (dir !== (dir = path.dirname(dir))) {
+		const tsconfig = path.join(dir, 'tsconfig.json');
+		const jsconfig = path.join(dir, 'jsconfig.json');
+
+		if (fs.existsSync(tsconfig)) {
+			config_filename = tsconfig;
+			break;
+		}
+
+		if (fs.existsSync(jsconfig)) {
+			config_filename = jsconfig;
+			break;
+		}
+	}
+
+	if (!config_filename) {
+		throw new Error('Failed to locate tsconfig or jsconfig');
+	}
+
+	const { error, config } = ts.readConfigFile(config_filename, ts.sys.readFile);
+
+	if (error) {
+		throw new Error('Malformed tsconfig\n' + JSON.stringify(error, null, 2));
+	}
+
+	// Do this so TS will not search for initial files which might take a while
+	config.include = [];
+	config.files = [];
+	const { options } = ts.parseJsonConfigFileContent(
+		config,
+		ts.sys,
+		path.dirname(config_filename),
+		{ sourceMap: false },
+		config_filename
+	);
+	return options;
+}

package/src/packaging/utils.js

@@ -0,0 +1,143 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { posixify, mkdirp, walk } from '../utils/filesystem.js';
+
+/**
+ * Resolves the `$lib` alias.
+ *
+ * TODO: make this more generic to also handle other aliases the user could have defined via
+ * `kit.alias`. Also investigate how to do this in a more robust way (right now regex string
+ * replacement is used).
+ * For more discussion see https://github.com/sveltejs/kit/pull/2453
+ *
+ * @param {string} file Relative to the lib root
+ * @param {string} content
+ * @param {import('types').ValidatedConfig} config
+ * @returns {string}
+ */
+export function resolve_lib_alias(file, content, config) {
+	/**
+	 * @param {string} match
+	 * @param {string} _
+	 * @param {string} import_path
+	 */
+	const replace_import_path = (match, _, import_path) => {
+		if (!import_path.startsWith('$lib/')) {
+			return match;
+		}
+
+		const full_path = path.join(config.kit.files.lib, file);
+		const full_import_path = path.join(config.kit.files.lib, import_path.slice('$lib/'.length));
+		let resolved = posixify(path.relative(path.dirname(full_path), full_import_path));
+		resolved = resolved.startsWith('.') ? resolved : './' + resolved;
+		return match.replace(import_path, resolved);
+	};
+	content = content.replace(/from\s+('|")([^"';,]+?)\1/g, replace_import_path);
+	content = content.replace(/import\s*\(\s*('|")([^"';,]+?)\1\s*\)/g, replace_import_path);
+	return content;
+}
+
+/**
+ * Strip out lang="X" or type="text/X" tags. Doing it here is only a temporary solution.
+ * See https://github.com/sveltejs/kit/issues/2450 for ideas for places where it's handled better.
+ *
+ * @param {string} content
+ */
+export function strip_lang_tags(content) {
+	return content
+		.replace(/(<!--[^]*?-->)|(<script[^>]*?)\s(?:type|lang)=(["']).*?\3/g, '$1$2')
+		.replace(/(<!--[^]*?-->)|(<style[^>]*?)\s(?:type|lang)=(["']).*?\3/g, '$1$2');
+}
+
+/**
+ * @param {string} file
+ * @param {Parameters<typeof fs.writeFileSync>[1]} contents
+ */
+export function write(file, contents) {
+	mkdirp(path.dirname(file));
+	fs.writeFileSync(file, contents);
+}
+
+/**
+ * @param {import('types').ValidatedConfig} config
+ * @returns {import('./types').File[]}
+ */
+export function scan(config) {
+	return walk(config.kit.files.lib).map((file) => analyze(config, file));
+}
+
+/**
+ * @param {import('types').ValidatedConfig} config
+ * @param {string} file
+ * @returns {import('./types').File}
+ */
+export function analyze(config, file) {
+	const name = posixify(file);
+
+	const svelte_extension = config.extensions.find((ext) => name.endsWith(ext));
+
+	const base = svelte_extension ? name : name.slice(0, -path.extname(name).length);
+
+	const dest = svelte_extension
+		? name.slice(0, -svelte_extension.length) + '.svelte'
+		: name.endsWith('.d.ts')
+		? name
+		: name.endsWith('.ts')
+		? name.slice(0, -3) + '.js'
+		: name;
+
+	return {
+		name,
+		dest,
+		base,
+		is_included: config.kit.package.files(name),
+		is_exported: config.kit.package.exports(name),
+		is_svelte: !!svelte_extension
+	};
+}
+
+/**
+ * @param {string} cwd
+ * @param {import('./types').File[]} files
+ */
+export function generate_pkg(cwd, files) {
+	const pkg = JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8'));
+
+	// Remove fields that are specific to the original package.json
+	// See: https://pnpm.io/package_json#publishconfigdirectory
+	delete pkg.publishConfig?.directory;
+	delete pkg.linkDirectory?.directory;
+	delete pkg.scripts;
+
+	pkg.type = 'module';
+
+	pkg.exports = {
+		'./package.json': './package.json',
+		...pkg.exports
+	};
+
+	/** @type {Record<string, string>} */
+	const clashes = {};
+
+	for (const file of files) {
+		if (file.is_included && file.is_exported) {
+			const original = `$lib/${file.name}`;
+			const entry = `./${file.dest}`;
+			const key = entry.replace(/\/index\.js$|(\/[^/]+)\.js$/, '$1');
+
+			if (clashes[key]) {
+				throw new Error(
+					`Duplicate "${key}" export. Please remove or rename either ${clashes[key]} or ${original}`
+				);
+			}
+
+			if (!pkg.exports[key]) {
+				pkg.exports[key] = entry;
+			}
+
+			clashes[key] = original;
+		}
+	}
+
+	return pkg;
+}

package/src/runtime/app/env.js

@@ -0,0 +1,11 @@
+/**
+ * @type {import('$app/env').browser}
+ */
+export const browser = !import.meta.env.SSR;
+
+/**
+ * @type {import('$app/env').dev}
+ */
+export const dev = __SVELTEKIT_DEV__;
+
+export { prerendering } from '../env.js';

package/src/runtime/app/navigation.js

@@ -0,0 +1,22 @@
+import { client } from '../client/singletons.js';
+
+/**
+ * @param {string} name
+ */
+function guard(name) {
+	return () => {
+		throw new Error(`Cannot call ${name}(...) on the server`);
+	};
+}
+
+const ssr = import.meta.env.SSR;
+
+export const disableScrollHandling = ssr
+	? guard('disableScrollHandling')
+	: client.disable_scroll_handling;
+export const goto = ssr ? guard('goto') : client.goto;
+export const invalidate = ssr ? guard('invalidate') : client.invalidate;
+export const prefetch = ssr ? guard('prefetch') : client.prefetch;
+export const prefetchRoutes = ssr ? guard('prefetchRoutes') : client.prefetch_routes;
+export const beforeNavigate = ssr ? () => {} : client.before_navigate;
+export const afterNavigate = ssr ? () => {} : client.after_navigate;

package/src/runtime/app/paths.js

@@ -0,0 +1 @@
+export { base, assets } from '../paths.js';

package/src/runtime/app/stores.js

@@ -0,0 +1,94 @@
+import { getContext } from 'svelte';
+import { browser } from './env.js';
+
+// TODO remove this (for 1.0? after 1.0?)
+let warned = false;
+export function stores() {
+	if (!warned) {
+		console.error('stores() is deprecated; use getStores() instead');
+		warned = true;
+	}
+	return getStores();
+}
+
+/**
+ * @type {import('$app/stores').getStores}
+ */
+export const getStores = () => {
+	const stores = getContext('__svelte__');
+
+	return {
+		page: {
+			subscribe: stores.page.subscribe
+		},
+		navigating: {
+			subscribe: stores.navigating.subscribe
+		},
+		// TODO remove this (for 1.0? after 1.0?)
+		// @ts-expect-error - deprecated, not part of type definitions, but still callable
+		get preloading() {
+			console.error('stores.preloading is deprecated; use stores.navigating instead');
+			return {
+				subscribe: stores.navigating.subscribe
+			};
+		},
+		session: stores.session,
+		updated: stores.updated
+	};
+};
+
+/** @type {typeof import('$app/stores').page} */
+export const page = {
+	/** @param {(value: any) => void} fn */
+	subscribe(fn) {
+		const store = getStores().page;
+		return store.subscribe(fn);
+	}
+};
+
+/** @type {typeof import('$app/stores').navigating} */
+export const navigating = {
+	subscribe(fn) {
+		const store = getStores().navigating;
+		return store.subscribe(fn);
+	}
+};
+
+/** @param {string} verb */
+const throw_error = (verb) => {
+	throw new Error(
+		browser
+			? `Cannot ${verb} session store before subscribing`
+			: `Can only ${verb} session store in browser`
+	);
+};
+
+/** @type {typeof import('$app/stores').session} */
+export const session = {
+	subscribe(fn) {
+		const store = getStores().session;
+
+		if (browser) {
+			session.set = store.set;
+			session.update = store.update;
+		}
+
+		return store.subscribe(fn);
+	},
+	set: () => throw_error('set'),
+	update: () => throw_error('update')
+};
+
+/** @type {typeof import('$app/stores').updated} */
+export const updated = {
+	subscribe(fn) {
+		const store = getStores().updated;
+
+		if (browser) {
+			updated.check = store.check;
+		}
+
+		return store.subscribe(fn);
+	},
+	check: () => throw_error('check')
+};

package/src/runtime/client/ambient.d.ts

@@ -0,0 +1,17 @@
+declare module '__GENERATED__/client-manifest.js' {
+	import { CSRPageNodeLoader, ParamMatcher } from 'types';
+
+	/**
+	 * A list of all the error/layout/page nodes used in the app
+	 */
+	export const nodes: CSRPageNodeLoader[];
+
+	/**
+	 * A map of `[routeId: string]: [errors, layouts, page]` tuples, which
+	 * is parsed into an array of routes on startup. The numbers refer to the
+	 * indices in `nodes`.
+	 */
+	export const dictionary: Record<string, [number[], number[], number]>;
+
+	export const matchers: Record<string, ParamMatcher>;
+}