@fuzdev/gro 0.192.0

package/src/lib/esbuild_plugin_svelte.ts

@@ -0,0 +1,134 @@
+import * as esbuild from 'esbuild';
+import {
+	compile,
+	compileModule,
+	preprocess,
+	type CompileOptions,
+	type ModuleCompileOptions,
+	type PreprocessorGroup,
+} from 'svelte/compiler';
+import {readFile} from 'node:fs/promises';
+import {relative} from 'node:path';
+
+import {to_define_import_meta_env, default_ts_transform_options} from './esbuild_helpers.ts';
+import {
+	default_svelte_config,
+	to_default_compile_module_options,
+	type ParsedSvelteConfig,
+} from './svelte_config.ts';
+import {TS_MATCHER, SVELTE_MATCHER, SVELTE_RUNES_MATCHER} from './constants.ts';
+
+export interface EsbuildPluginSvelteOptions {
+	dev: boolean;
+	base_url: ParsedSvelteConfig['base_url'];
+	dir?: string;
+	svelte_compile_options?: CompileOptions;
+	svelte_compile_module_options?: ModuleCompileOptions;
+	svelte_preprocessors?: PreprocessorGroup | Array<PreprocessorGroup>;
+	ts_transform_options?: esbuild.TransformOptions;
+	is_ts?: (filename: string) => boolean;
+}
+
+export const esbuild_plugin_svelte = (options: EsbuildPluginSvelteOptions): esbuild.Plugin => {
+	const {
+		dev,
+		base_url,
+		dir = process.cwd(),
+		svelte_compile_options = default_svelte_config.svelte_compile_options,
+		svelte_compile_module_options = to_default_compile_module_options(svelte_compile_options),
+		svelte_preprocessors,
+		ts_transform_options = default_ts_transform_options,
+		is_ts = (f) => TS_MATCHER.test(f),
+	} = options;
+
+	const final_ts_transform_options: esbuild.TransformOptions = {
+		...ts_transform_options,
+		define: to_define_import_meta_env(dev, base_url),
+		sourcemap: 'inline',
+	};
+
+	return {
+		name: 'svelte',
+		setup: (build) => {
+			build.onLoad({filter: SVELTE_RUNES_MATCHER}, async ({path}) => {
+				const source = await readFile(path, 'utf8');
+				try {
+					const filename = relative(dir, path);
+					const js_source = is_ts(filename)
+						? (
+								await esbuild.transform(source, {
+									...final_ts_transform_options,
+									sourcefile: filename,
+								})
+							).code // TODO @many use warnings? handle not-inline sourcemaps?
+						: source;
+					const {js, warnings} = compileModule(js_source, {
+						...svelte_compile_module_options,
+						filename,
+					});
+					const contents = js.code + '//# sourceMappingURL=' + js.map.toUrl();
+					return {
+						contents,
+						warnings: warnings.map((w) => convert_svelte_message_to_esbuild(filename, source, w)),
+					};
+				} catch (error) {
+					return {errors: [convert_svelte_message_to_esbuild(path, source, error)]};
+				}
+			});
+
+			build.onLoad({filter: SVELTE_MATCHER}, async ({path}) => {
+				let source = await readFile(path, 'utf8');
+				try {
+					const filename = relative(dir, path);
+					const preprocessed = svelte_preprocessors
+						? await preprocess(source, svelte_preprocessors, {filename})
+						: null;
+					if (preprocessed?.code) source = preprocessed.code;
+					const {js, warnings} = compile(source, {...svelte_compile_options, filename});
+					const contents = js.code + '//# sourceMappingURL=' + js.map.toUrl();
+					return {
+						contents,
+						warnings: warnings.map((w) => convert_svelte_message_to_esbuild(filename, source, w)),
+					};
+				} catch (error) {
+					return {errors: [convert_svelte_message_to_esbuild(path, source, error)]};
+				}
+			});
+		},
+	};
+};
+
+/**
+ * Following the example in the esbuild docs:
+ * https://esbuild.github.io/plugins/#svelte-plugin
+ */
+const convert_svelte_message_to_esbuild = (
+	path: string,
+	source: string,
+	{message, start, end}: SvelteError,
+): esbuild.PartialMessage => {
+	let location: esbuild.PartialMessage['location'] = null;
+	if (start && end) {
+		const lineText = source.split(/\r\n|\r|\n/g)[start.line - 1] ?? '';
+		const lineEnd = start.line === end.line ? end.column : lineText.length;
+		location = {
+			file: path,
+			line: start.line,
+			lineText,
+			column: start.column,
+			length: lineEnd - start.column,
+		};
+	}
+	return {text: message, location};
+};
+
+// these are not exported by Svelte
+interface SvelteError {
+	message: string;
+	start?: LineInfo;
+	end?: LineInfo;
+}
+interface LineInfo {
+	line: number;
+	column: number;
+}

package/src/lib/esbuild_plugin_sveltekit_local_imports.ts

@@ -0,0 +1,38 @@
+import type * as esbuild from 'esbuild';
+import {readFile} from 'node:fs/promises';
+import {dirname} from 'node:path';
+
+import {resolve_specifier} from './resolve_specifier.ts';
+import {EVERYTHING_MATCHER} from './constants.ts';
+
+/**
+ * Adds support for imports to both `.ts` and `.js`,
+ * as well as imports without extensions that resolve to `.js` or `.ts`.
+ * Prefers `.ts` over any `.js`, and falls back to `.ts` if no file is found.
+ */
+export const esbuild_plugin_sveltekit_local_imports = (): esbuild.Plugin => ({
+	name: 'sveltekit_local_imports',
+	setup: (build) => {
+		build.onResolve({filter: /^(\/|\.)/}, async (args) => {
+			const {path, importer} = args;
+			if (!importer) return {path};
+			const {path_id, namespace} = await resolve_specifier(path, dirname(importer));
+			return {path: path_id, namespace}; // `namespace` may be `undefined`, but esbuild needs the absolute path for json etc
+		});
+		build.onLoad(
+			{filter: EVERYTHING_MATCHER, namespace: 'sveltekit_local_imports_ts'},
+			async ({path}) => ({
+				contents: await readFile(path),
+				loader: 'ts',
+				resolveDir: dirname(path),
+			}),
+		);
+		build.onLoad(
+			{filter: EVERYTHING_MATCHER, namespace: 'sveltekit_local_imports_js'},
+			async ({path}) => ({
+				contents: await readFile(path),
+				resolveDir: dirname(path),
+			}),
+		);
+	},
+});

package/src/lib/esbuild_plugin_sveltekit_shim_alias.ts

@@ -0,0 +1,27 @@
+import type * as esbuild from 'esbuild';
+import {escape_regexp} from '@fuzdev/fuz_util/regexp.js';
+import {join} from 'node:path';
+
+export interface EsbuildPluginSveltekitShimAliasOptions {
+	dir?: string;
+	alias?: Record<string, string>;
+}
+
+export const esbuild_plugin_sveltekit_shim_alias = ({
+	dir = process.cwd(),
+	alias,
+}: EsbuildPluginSveltekitShimAliasOptions): esbuild.Plugin => ({
+	name: 'sveltekit_shim_alias',
+	setup: (build) => {
+		const aliases: Record<string, string> = {$lib: 'src/lib', ...alias};
+		// Create a Go-compatible regexp
+		const filter = new RegExp(`^(?:${Object.keys(aliases).map(escape_regexp).join('|')})`);
+		build.onResolve({filter}, async (args) => {
+			const {path, ...rest} = args;
+			// Find which alias prefix matches
+			const prefix = Object.keys(aliases).find((key) => path.startsWith(key));
+			if (!prefix) return null;
+			return build.resolve(join(dir, aliases[prefix] + path.substring(prefix.length)), rest);
+		});
+	},
+});

package/src/lib/esbuild_plugin_sveltekit_shim_app.ts

@@ -0,0 +1,42 @@
+import type * as esbuild from 'esbuild';
+
+import {
+	render_sveltekit_shim_app_environment,
+	render_sveltekit_shim_app_paths,
+	sveltekit_shim_app_specifiers,
+} from './sveltekit_shim_app.ts';
+import type {ParsedSvelteConfig} from './svelte_config.ts';
+import {EVERYTHING_MATCHER} from './constants.ts';
+
+export interface EsbuildPluginSveltekitShimAppOptions {
+	dev: boolean;
+	base_url: ParsedSvelteConfig['base_url'];
+	assets_url: ParsedSvelteConfig['assets_url'];
+}
+
+export const esbuild_plugin_sveltekit_shim_app = ({
+	dev,
+	base_url,
+	assets_url,
+}: EsbuildPluginSveltekitShimAppOptions): esbuild.Plugin => ({
+	name: 'sveltekit_shim_app',
+	setup: (build) => {
+		build.onResolve({filter: /^\$app\/(forms|navigation|stores)$/}, ({path, ...rest}) =>
+			build.resolve(sveltekit_shim_app_specifiers.get(path)!, rest),
+		);
+		build.onResolve({filter: /^\$app\/paths$/}, ({path}) => ({
+			path: sveltekit_shim_app_specifiers.get(path)!,
+			namespace: 'sveltekit_shim_app_paths',
+		}));
+		build.onLoad({filter: EVERYTHING_MATCHER, namespace: 'sveltekit_shim_app_paths'}, () => ({
+			contents: render_sveltekit_shim_app_paths(base_url, assets_url),
+		}));
+		build.onResolve({filter: /^\$app\/environment$/}, ({path}) => ({
+			path: sveltekit_shim_app_specifiers.get(path)!,
+			namespace: 'sveltekit_shim_app_environment',
+		}));
+		build.onLoad({filter: EVERYTHING_MATCHER, namespace: 'sveltekit_shim_app_environment'}, () => ({
+			contents: render_sveltekit_shim_app_environment(dev),
+		}));
+	},
+});

package/src/lib/esbuild_plugin_sveltekit_shim_env.ts

@@ -0,0 +1,47 @@
+import type * as esbuild from 'esbuild';
+
+import {render_env_shim_module} from './sveltekit_shim_env.ts';
+import {SVELTEKIT_ENV_MATCHER, EVERYTHING_MATCHER} from './constants.ts';
+
+export interface EsbuildPluginSveltekitShimEnvOptions {
+	dev: boolean;
+	public_prefix?: string;
+	private_prefix?: string;
+	env_dir?: string;
+	env_files?: Array<string>;
+	ambient_env?: Record<string, string>;
+}
+
+const namespace = 'sveltekit_shim_env';
+
+export const esbuild_plugin_sveltekit_shim_env = ({
+	dev,
+	public_prefix,
+	private_prefix,
+	env_dir,
+	env_files,
+	ambient_env,
+}: EsbuildPluginSveltekitShimEnvOptions): esbuild.Plugin => ({
+	name: 'sveltekit_shim_env',
+	setup: (build) => {
+		build.onResolve({filter: SVELTEKIT_ENV_MATCHER}, ({path}) => ({path, namespace}));
+		build.onLoad({filter: EVERYTHING_MATCHER, namespace}, ({path}) => {
+			const matches = SVELTEKIT_ENV_MATCHER.exec(path);
+			const mode = matches![1] as 'static' | 'dynamic';
+			const visibility = matches![2] as 'public' | 'private';
+			return {
+				loader: 'ts',
+				contents: render_env_shim_module(
+					dev,
+					mode,
+					visibility,
+					public_prefix,
+					private_prefix,
+					env_dir,
+					env_files,
+					ambient_env,
+				),
+			};
+		});
+	},
+});