@fuzdev/gro 0.192.0

package/src/lib/sveltekit_shim_app.ts

@@ -0,0 +1,41 @@
+import type {ParsedSvelteConfig} from './svelte_config.ts';
+
+export const SVELTEKIT_SHIM_APP_PATHS_MATCHER = /\/util\/sveltekit_shim_app_paths\.js$/;
+export const SVELTEKIT_SHIM_APP_ENVIRONMENT_MATCHER = /\/util\/sveltekit_shim_app_environment\.js$/;
+
+/**
+ * Maps SvelteKit `$app` specifiers to their Gro shims.
+ * @see https://kit.svelte.dev/docs/modules
+ */
+export const sveltekit_shim_app_specifiers = new Map([
+	['$app/environment', '@fuzdev/gro/sveltekit_shim_app_environment.js'],
+	['$app/forms', '@fuzdev/gro/sveltekit_shim_app_forms.js'],
+	['$app/navigation', '@fuzdev/gro/sveltekit_shim_app_navigation.js'],
+	['$app/paths', '@fuzdev/gro/sveltekit_shim_app_paths.js'],
+	['$app/state', '@fuzdev/gro/sveltekit_shim_app_state.js'],
+]);
+
+export const render_sveltekit_shim_app_paths = (
+	base_url: ParsedSvelteConfig['base_url'] = '',
+	assets_url: ParsedSvelteConfig['assets_url'] = '',
+): string => `// shim for $app/paths
+// @see https://github.com/sveltejs/kit/issues/1485
+
+export const assets = ${JSON.stringify(assets_url)};
+export const base = ${JSON.stringify(base_url)};
+`;
+
+// TODO improve support
+// `dev` is not guaranteed to be the same as `MODE` - https://kit.svelte.dev/docs/modules#$app-environment-dev
+// `version` is `config.kit.version.name` but I couldn't see how to load a SvelteKit `ValidatedConfig`
+// `building` is just being hardcoded, might be better (but still not correct) to be `!dev`
+export const render_sveltekit_shim_app_environment = (
+	dev: boolean,
+): string => `// shim for $app/environment
+// @see https://github.com/sveltejs/kit/issues/1485
+
+export const browser = false;
+export const building = false;
+export const dev = ${JSON.stringify(dev)};
+export const version = 'TODO';
+`;

package/src/lib/sveltekit_shim_app_environment.ts

@@ -0,0 +1,16 @@
+// shim for $app/environment
+// @see https://github.com/sveltejs/kit/issues/1485
+
+/**
+ * This file is created dynamically by `render_sveltekit_shim_app_environment`
+ * but exists here for the sake of the Node loader.
+ * There may be a cleaner workaround but I couldn't find it.
+ * @see https://github.com/nodejs/loaders for details about the forthcoming virtual file support
+ *
+ * @module
+ */
+
+export const browser = false;
+export const building = false;
+export const dev = true;
+export const version = 'TODO';

package/src/lib/sveltekit_shim_app_forms.ts

@@ -0,0 +1,13 @@
+// shim for $app/forms
+// @see https://github.com/sveltejs/kit/issues/1485
+
+import type {
+	applyAction as base_applyAction,
+	deserialize as base_deserialize,
+	enhance as base_enhance,
+} from '$app/forms';
+import {noop, noop_async} from '@fuzdev/fuz_util/function.js';
+
+export const applyAction: typeof base_applyAction = noop_async;
+export const deserialize: typeof base_deserialize = () => ({}) as any;
+export const enhance: typeof base_enhance = () => ({destroy: noop});

package/src/lib/sveltekit_shim_app_navigation.ts

@@ -0,0 +1,23 @@
+// shim for $app/navigation
+// @see https://github.com/sveltejs/kit/issues/1485
+
+import type {
+	afterNavigate as base_afterNavigate,
+	beforeNavigate as base_beforeNavigate,
+	disableScrollHandling as base_disableScrollHandling,
+	goto as base_goto,
+	invalidate as base_invalidate,
+	invalidateAll as base_invalidateAll,
+	preloadCode as base_preloadCode,
+	preloadData as base_preloadData,
+} from '$app/navigation';
+import {noop, noop_async} from '@fuzdev/fuz_util/function.js';
+
+export const afterNavigate: typeof base_afterNavigate = noop;
+export const beforeNavigate: typeof base_beforeNavigate = noop;
+export const disableScrollHandling: typeof base_disableScrollHandling = noop;
+export const goto: typeof base_goto = noop_async;
+export const invalidate: typeof base_invalidate = noop_async;
+export const invalidateAll: typeof base_invalidateAll = noop_async;
+export const preloadCode: typeof base_preloadCode = noop_async;
+export const preloadData: typeof base_preloadData = noop_async;

package/src/lib/sveltekit_shim_app_paths.ts

@@ -0,0 +1,26 @@
+// shim for $app/paths
+// @see https://github.com/sveltejs/kit/issues/1485
+
+/**
+ * This file is created dynamically by `render_sveltekit_shim_app_paths`
+ * but exists here for the sake of the Node loader.
+ * There may be a cleaner workaround but I couldn't find it.
+ * @see https://github.com/nodejs/loaders for details about the forthcoming virtual file support
+ *
+ * @module
+ */
+
+import type {
+	resolve as base_resolve,
+	asset as base_asset,
+	resolveRoute as base_resolveRoute,
+} from '$app/paths';
+import {noop} from '@fuzdev/fuz_util/function.js';
+
+export const assets = '';
+/** @deprecated */
+export const base = '';
+export const resolve: typeof base_resolve = (v, ..._rest) => ('/' + v.replace(/^\//, '')) as any; // TODO needs to use SvelteKit config base
+/** @deprecated */
+export const resolveRoute: typeof base_resolveRoute = noop; // eslint-disable-line @typescript-eslint/no-deprecated
+export const asset: typeof base_asset = (v) => ('/' + v.replace(/^\//, '')) as any; // TODO needs to use SvelteKit config base

package/src/lib/sveltekit_shim_app_state.ts

@@ -0,0 +1,35 @@
+// shim for $app/state
+// @see https://github.com/sveltejs/kit/issues/1485
+
+import type {
+	navigating as base_navigating,
+	page as base_page,
+	updated as base_updated,
+} from '$app/state';
+
+export const navigating: typeof base_navigating = {
+	from: null,
+	to: null,
+	type: null,
+	willUnload: null,
+	delta: null,
+	complete: null,
+};
+
+export const page: typeof base_page = {
+	data: {},
+	form: null,
+	error: null,
+	params: {},
+	route: {id: null},
+	state: {},
+	status: -1,
+	url: new URL('https://github.com/fuzdev/gro') as any, // TODO maybe use package.json?
+};
+
+export const updated: typeof base_updated = {
+	current: false,
+	check: () => {
+		throw Error('Can only call updated.check() in the browser');
+	},
+};

package/src/lib/sveltekit_shim_env.ts

@@ -0,0 +1,45 @@
+import {load_env} from './env.ts';
+
+// TODO might want to do more escaping and validation
+
+/**
+ * Generates a module shim for SvelteKit's `$env` imports.
+ */
+export const render_env_shim_module = (
+	dev: boolean,
+	mode: 'static' | 'dynamic',
+	visibility: 'public' | 'private',
+	public_prefix = 'PUBLIC_',
+	private_prefix = '',
+	env_dir?: string,
+	env_files?: Array<string>,
+	ambient_env?: Record<string, string | undefined>,
+): string => {
+	const env = load_env(
+		dev,
+		visibility,
+		public_prefix,
+		private_prefix,
+		env_dir,
+		env_files,
+		ambient_env,
+	);
+	if (mode === 'static') {
+		return `// shim for $env/static/${visibility}
+// @see https://github.com/sveltejs/kit/issues/1485
+${Object.entries(env)
+	.map(([k, v]) => `export let ${k} = ${JSON.stringify(v)};`)
+	.join('\n')}
+		`;
+	} else {
+		return `// shim for $env/dynamic/${visibility}
+// @see https://github.com/sveltejs/kit/issues/1485
+import {load_env} from '@fuzdev/gro/env.js';
+export const env = load_env(${dev}, ${JSON.stringify(visibility)}, ${JSON.stringify(
+			public_prefix,
+		)}, ${JSON.stringify(private_prefix)}, ${JSON.stringify(env_dir)}, ${JSON.stringify(
+			env_files,
+		)}, ${JSON.stringify(ambient_env)});
+		`;
+	}
+};

package/src/lib/sync.task.ts

@@ -0,0 +1,47 @@
+import {z} from 'zod';
+import {spawn} from '@fuzdev/fuz_util/process.js';
+
+import {TaskError, type Task} from './task.ts';
+import {package_json_sync} from './package_json.ts';
+import {sveltekit_sync} from './sveltekit_helpers.ts';
+
+/** @nodocs */
+export const Args = z.strictObject({
+	sveltekit: z.boolean().meta({description: 'dual of no-sveltekit'}).default(true),
+	'no-sveltekit': z.boolean().meta({description: 'opt out of svelte-kit sync'}).default(false),
+	package_json: z.boolean().meta({description: 'dual of no-package_json'}).default(true),
+	'no-package_json': z.boolean().meta({description: 'opt out of package.json sync'}).default(false),
+	gen: z.boolean().meta({description: 'dual of no-gen'}).default(true),
+	'no-gen': z.boolean().meta({description: 'opt out of running gen'}).default(false),
+	install: z.boolean().meta({description: 'opt into installing packages'}).default(false),
+});
+export type Args = z.infer<typeof Args>;
+
+/** @nodocs */
+export const task: Task<Args> = {
+	summary: 'run `gro gen`, update `package.json`, and optionally install packages to sync up',
+	Args,
+	run: async ({args, invoke_task, config, log}): Promise<void> => {
+		const {sveltekit, package_json, gen, install} = args;
+
+		if (install) {
+			const result = await spawn(config.pm_cli, ['install']);
+			if (!result.ok) {
+				throw new TaskError(`Failed \`${config.pm_cli} install\``);
+			}
+		}
+
+		if (sveltekit) {
+			await sveltekit_sync(undefined, config.pm_cli);
+			log.info('synced SvelteKit');
+		}
+
+		if (package_json && config.map_package_json) {
+			await package_json_sync(config.map_package_json, log);
+		}
+
+		if (gen) {
+			await invoke_task('gen');
+		}
+	},
+};

package/src/lib/task.ts

@@ -0,0 +1,245 @@
+import type {Args} from '@fuzdev/fuz_util/args.js';
+import {fs_search} from '@fuzdev/fuz_util/fs.js';
+import type {Logger} from '@fuzdev/fuz_util/log.js';
+import type {PathId} from '@fuzdev/fuz_util/path.js';
+import type {Result} from '@fuzdev/fuz_util/result.js';
+import {ensure_end, strip_end, strip_start} from '@fuzdev/fuz_util/string.js';
+import type {Timings} from '@fuzdev/fuz_util/timings.js';
+import {isAbsolute, join, relative} from 'node:path';
+import {styleText as st} from 'node:util';
+import type {z} from 'zod';
+import type {GroConfig} from './gro_config.ts';
+import type {ParsedSvelteConfig} from './svelte_config.ts';
+import {
+	resolve_input_files,
+	resolve_input_paths,
+	type InputPath,
+	type ResolvedInputFile,
+	type ResolvedInputPath,
+} from './input_path.ts';
+import {GRO_DIST_DIR, print_path} from './paths.ts';
+import {load_modules, type LoadModulesFailure, type ModuleMeta} from './modules.ts';
+import type {Filer} from './filer.ts';
+
+export interface Task<
+	TArgs = Args,
+	TArgsSchema extends z.ZodType<Args, Args> = z.ZodType<Args, Args>, // TODO improve type? separate input/output?
+	TReturn = unknown,
+> {
+	run: (ctx: TaskContext<TArgs>) => TReturn | Promise<TReturn>; // TODO unused return value
+	summary?: string;
+	Args?: TArgsSchema;
+}
+
+export interface TaskContext<TArgs = object> {
+	args: TArgs;
+	config: GroConfig;
+	svelte_config: ParsedSvelteConfig;
+	filer: Filer;
+	log: Logger;
+	timings: Timings;
+	invoke_task: InvokeTask;
+}
+
+export type InvokeTask = (task_name: string, args?: Args, config?: GroConfig) => Promise<void>;
+
+export const TASK_FILE_SUFFIX_TS = '.task.ts';
+export const TASK_FILE_SUFFIX_JS = '.task.js';
+export const TASK_FILE_SUFFIXES = [TASK_FILE_SUFFIX_TS, TASK_FILE_SUFFIX_JS]; // TODO from `GroConfig`, but needs to be used everywhere the constants are
+
+export const is_task_path = (path: string): boolean =>
+	path.endsWith(TASK_FILE_SUFFIX_TS) || path.endsWith(TASK_FILE_SUFFIX_JS);
+
+export const to_task_name = (
+	id: PathId,
+	task_root_dir: PathId,
+	input_path: InputPath,
+	root_path: PathId,
+): string => {
+	let task_name = id.startsWith(task_root_dir)
+		? strip_start(strip_start(id, task_root_dir), '/')
+		: id;
+	for (const suffix of TASK_FILE_SUFFIXES) {
+		task_name = strip_end(task_name, suffix);
+	}
+	if (ensure_end(task_root_dir, '/') === GRO_DIST_DIR) {
+		// TODO ideally it would display this in some contexts like the task progress logs,
+		// but not all, like printing the task list, UNLESS there's a local override
+		// return 'gro/' + task_name;
+		return task_name;
+	}
+	if (isAbsolute(input_path)) {
+		return relative(root_path, join(task_root_dir, task_name));
+	}
+	return task_name;
+};
+
+/**
+ * This is used by tasks to signal a known failure.
+ * It's useful for cleaning up logging because
+ * we usually don't need their stack trace.
+ */
+export class TaskError extends Error {}
+
+/**
+ * This is used to tell Gro to exit silently, usually still with with a non-zero exit code.
+ * Using it means error logging is handled by the code that threw it.
+ */
+export class SilentError extends Error {}
+
+export interface FoundTask {
+	input_path: InputPath;
+	id: PathId;
+	task_root_dir: PathId;
+}
+
+export interface FoundTasks {
+	resolved_input_files: Array<ResolvedInputFile>;
+	resolved_input_files_by_root_dir: Map<PathId, Array<ResolvedInputFile>>;
+	resolved_input_paths: Array<ResolvedInputPath>;
+	input_paths: Array<InputPath>;
+	task_root_dirs: Array<PathId>;
+}
+
+export type FindTasksResult = Result<{value: FoundTasks}, FindModulesFailure>;
+export type FindModulesFailure =
+	| {
+			type: 'unmapped_input_paths';
+			unmapped_input_paths: Array<InputPath>;
+			resolved_input_paths: Array<ResolvedInputPath>;
+			input_paths: Array<InputPath>;
+			task_root_dirs: Array<PathId>;
+			reasons: Array<string>;
+	  }
+	| {
+			type: 'input_directories_with_no_files';
+			input_directories_with_no_files: Array<InputPath>;
+			resolved_input_files: Array<ResolvedInputFile>;
+			resolved_input_files_by_root_dir: Map<PathId, Array<ResolvedInputFile>>;
+			resolved_input_paths: Array<ResolvedInputPath>;
+			input_paths: Array<InputPath>;
+			task_root_dirs: Array<PathId>;
+			reasons: Array<string>;
+	  };
+
+/**
+ * Finds modules from input paths. (see `src/lib/input_path.ts` for more)
+ */
+export const find_tasks = async (
+	input_paths: Array<InputPath>,
+	task_root_dirs: Array<PathId>,
+	config: GroConfig,
+	timings?: Timings,
+): Promise<FindTasksResult> => {
+	// Check which extension variation works - if it's a directory, prefer others first!
+	const timing_to_resolve_input_paths = timings?.start('resolve input paths');
+	const {resolved_input_paths, unmapped_input_paths} = await resolve_input_paths(
+		input_paths,
+		task_root_dirs,
+		TASK_FILE_SUFFIXES,
+	);
+	timing_to_resolve_input_paths?.();
+
+	// Error if any input path could not be mapped.
+	if (unmapped_input_paths.length) {
+		return {
+			ok: false,
+			type: 'unmapped_input_paths',
+			unmapped_input_paths,
+			resolved_input_paths,
+			input_paths,
+			task_root_dirs,
+			reasons: unmapped_input_paths.map((input_path) =>
+				st('red', `Input path ${print_path(input_path)} cannot be mapped to a file or directory.`),
+			),
+		};
+	}
+
+	// Find all of the files for any directories.
+	const timing_to_resolve_input_files = timings?.start('resolve input files');
+	const {resolved_input_files, resolved_input_files_by_root_dir, input_directories_with_no_files} =
+		await resolve_input_files(
+			resolved_input_paths,
+			async (id) =>
+				await fs_search(id, {
+					filter: config.search_filters,
+					file_filter: (p) => TASK_FILE_SUFFIXES.some((s) => p.endsWith(s)),
+				}),
+		);
+	timing_to_resolve_input_files?.();
+
+	// Error if any input path has no files. (means we have an empty directory)
+	if (input_directories_with_no_files.length) {
+		return {
+			ok: false,
+			type: 'input_directories_with_no_files',
+			input_directories_with_no_files,
+			resolved_input_files,
+			resolved_input_files_by_root_dir,
+			resolved_input_paths,
+			input_paths,
+			task_root_dirs,
+			reasons: input_directories_with_no_files.map((input_path) =>
+				st('red', `Input directory contains no matching files: ${print_path(input_path)}`),
+			),
+		};
+	}
+
+	return {
+		ok: true,
+		value: {
+			resolved_input_files,
+			resolved_input_files_by_root_dir,
+			resolved_input_paths,
+			input_paths,
+			task_root_dirs,
+		},
+	};
+};
+
+export interface LoadedTasks {
+	modules: Array<TaskModuleMeta>;
+	found_tasks: FoundTasks;
+}
+
+export interface TaskModule {
+	task: Task;
+}
+
+export interface TaskModuleMeta extends ModuleMeta<TaskModule> {
+	name: string;
+}
+
+export type LoadTasksResult = Result<{value: LoadedTasks}, LoadTasksFailure>;
+export type LoadTasksFailure = LoadModulesFailure<TaskModuleMeta>;
+
+export const load_tasks = async (
+	found_tasks: FoundTasks,
+	root_path: PathId = process.cwd(), // TODO @many isn't passed in anywhere, maybe hoist to `invoke_task` and others
+): Promise<LoadTasksResult> => {
+	const loaded_modules = await load_modules(
+		found_tasks.resolved_input_files,
+		validate_task_module,
+		(resolved_input_file, mod): TaskModuleMeta => ({
+			id: resolved_input_file.id,
+			mod,
+			name: to_task_name(
+				resolved_input_file.id,
+				resolved_input_file.resolved_input_path.root_dir,
+				resolved_input_file.resolved_input_path.input_path,
+				root_path,
+			),
+		}),
+	);
+	if (!loaded_modules.ok) {
+		return loaded_modules;
+	}
+
+	return {
+		ok: true,
+		value: {modules: loaded_modules.modules, found_tasks},
+	};
+};
+
+export const validate_task_module = (mod: Record<string, any>): mod is TaskModule =>
+	!!mod.task && typeof mod.task.run === 'function';