@ryanatkn/gro 0.129.4 → 0.129.6

package/src/lib/search_fs.ts

@@ -0,0 +1,93 @@
+import {EMPTY_OBJECT} from '@ryanatkn/belt/object.js';
+import {to_array} from '@ryanatkn/belt/array.js';
+import {ensure_end} from '@ryanatkn/belt/string.js';
+import {isAbsolute, join} from 'node:path';
+import {existsSync, readdirSync} from 'node:fs';
+
+import type {File_Filter, Resolved_Path, Path_Filter} from './path.js';
+
+export interface Search_Fs_Options {
+	/**
+	 * One or more filter functions, any of which can short-circuit the search by returning `false`.
+	 */
+	filter?: Path_Filter | Path_Filter[];
+	/**
+	 * An array of file suffixes to include.
+	 */
+	file_filter?: File_Filter | File_Filter[];
+	/**
+	 * Pass `null` or `false` to speed things up at the cost of volatile ordering.
+	 */
+	sort?: boolean | null | ((a: Resolved_Path, b: Resolved_Path) => number);
+	/**
+	 * Set to `false` to include directories.
+	 */
+	include_directories?: boolean;
+	/**
+	 * Sets the cwd for `dir` unless it's an absolute path or `null`.
+	 */
+	cwd?: string | null;
+}
+
+export const search_fs = (
+	dir: string,
+	options: Search_Fs_Options = EMPTY_OBJECT,
+): Resolved_Path[] => {
+	const {
+		filter,
+		file_filter,
+		sort = default_sort,
+		include_directories = false,
+		cwd = process.cwd(),
+	} = options;
+
+	const final_dir = ensure_end(cwd && !isAbsolute(dir) ? join(cwd, dir) : dir, '/');
+
+	const filters =
+		!filter || (Array.isArray(filter) && !filter.length) ? undefined : to_array(filter);
+	const file_filters =
+		!file_filter || (Array.isArray(file_filter) && !file_filter.length)
+			? undefined
+			: to_array(file_filter);
+
+	if (!existsSync(final_dir)) return [];
+
+	const paths: Resolved_Path[] = [];
+	crawl(final_dir, paths, filters, file_filters, include_directories, null);
+
+	return sort ? paths.sort(typeof sort === 'boolean' ? default_sort : sort) : paths;
+};
+
+const default_sort = (a: Resolved_Path, b: Resolved_Path): number => a.path.localeCompare(b.path);
+
+const crawl = (
+	dir: string,
+	paths: Resolved_Path[],
+	filters: Path_Filter[] | undefined,
+	file_filter: File_Filter[] | undefined,
+	include_directories: boolean,
+	base_dir: string | null,
+): Resolved_Path[] => {
+	// This sync version is significantly faster than using the `fs/promises` version -
+	// it doesn't parallelize but that's not the common case in Gro.
+	const dirents = readdirSync(dir, {withFileTypes: true});
+	for (const dirent of dirents) {
+		const {name, parentPath} = dirent;
+		const is_directory = dirent.isDirectory();
+		const id = parentPath + name;
+		const include = !filters || filters.every((f) => f(id, is_directory));
+		if (include) {
+			const path = base_dir === null ? name : base_dir + '/' + name;
+			if (is_directory) {
+				const dir_id = id + '/';
+				if (include_directories) {
+					paths.push({path, id: dir_id, is_directory: true});
+				}
+				crawl(dir_id, paths, filters, file_filter, include_directories, path);
+			} else if (!file_filter || file_filter.every((f) => f(id))) {
+				paths.push({path, id, is_directory: false});
+			}
+		}
+	}
+	return paths;
+};

package/src/lib/src_json.test.ts

@@ -0,0 +1,49 @@
+import {test} from 'uvu';
+import * as assert from 'uvu/assert';
+
+import {to_src_modules} from './src_json.js';
+import {to_package_exports} from './package_json.js';
+import {paths} from './paths.js';
+
+test('to_package_modules', () => {
+	assert.equal(
+		to_src_modules(
+			to_package_exports([
+				'fixtures/modules/some_test_css.css',
+				'fixtures/modules/Some_Test_Svelte.svelte',
+				'fixtures/modules/some_test_ts.ts',
+				'fixtures/modules/some_test_json.json',
+			]),
+			undefined,
+			paths.source,
+		),
+		{
+			'./package.json': {path: 'package.json', declarations: []},
+			'./fixtures/modules/some_test_css.css': {
+				path: 'fixtures/modules/some_test_css.css',
+				declarations: [],
+			},
+			'./fixtures/modules/some_test_json.json': {
+				path: 'fixtures/modules/some_test_json.json',
+				declarations: [],
+			},
+			'./fixtures/modules/Some_Test_Svelte.svelte': {
+				path: 'fixtures/modules/Some_Test_Svelte.svelte',
+				declarations: [],
+			},
+			'./fixtures/modules/some_test_ts.js': {
+				path: 'fixtures/modules/some_test_ts.ts',
+				declarations: [
+					{name: 'a', kind: 'variable'},
+					{name: 'some_test_ts', kind: 'variable'},
+					{name: 'some_test_fn', kind: 'function'},
+					{name: 'Some_Test_Type', kind: 'type'},
+					{name: 'Some_Test_Interface', kind: 'type'},
+					{name: 'Some_Test_Class', kind: 'class'},
+				],
+			},
+		},
+	);
+});
+
+test.run();

package/src/lib/src_json.ts

@@ -0,0 +1,153 @@
+import {z} from 'zod';
+import {join} from 'node:path';
+import {strip_start} from '@ryanatkn/belt/string.js';
+import type {Logger} from '@ryanatkn/belt/log.js';
+import {Project} from 'ts-morph';
+import {existsSync} from 'node:fs';
+
+import {paths, replace_extension} from './paths.js';
+import {
+	transform_empty_object_to_undefined,
+	type Package_Json,
+	type Package_Json_Exports,
+} from './package_json.js';
+
+export const Src_Module_Declaration = z
+	.object({
+		name: z.string(), // the export identifier
+		// TODO these are poorly named, and they're somewhat redundant with `kind`,
+		// they were added to distinguish `VariableDeclaration` functions and non-functions
+		kind: z.enum(['type', 'function', 'variable', 'class']).nullable(),
+		// code: z.string(), // TODO experiment with `getType().getText()`, some of them return the same as `name`
+	})
+	.passthrough();
+export type Src_Module_Declaration = z.infer<typeof Src_Module_Declaration>;
+
+export const Src_Module = z
+	.object({
+		path: z.string(),
+		declarations: z.array(Src_Module_Declaration),
+	})
+	.passthrough();
+export type Src_Module = z.infer<typeof Src_Module>;
+
+export const Src_Modules = z.record(Src_Module);
+export type Src_Modules = z.infer<typeof Src_Modules>;
+
+/**
+ * @see https://github.com/ryanatkn/gro/blob/main/src/lib/docs/gro_plugin_sveltekit_app.md#well-known-src
+ */
+export const Src_Json = z.intersection(
+	z.record(z.unknown()), // TODO is this what we want?
+	z
+		.object({
+			name: z.string(), // same as Package_Json
+			version: z.string(), // same as Package_Json
+			modules: Src_Modules.transform(transform_empty_object_to_undefined).optional(),
+		})
+		.passthrough(),
+);
+export type Src_Json = z.infer<typeof Src_Json>;
+
+export type Map_Src_Json = (src_json: Src_Json) => Src_Json | null | Promise<Src_Json | null>;
+
+export const create_src_json = (
+	package_json: Package_Json,
+	log?: Logger,
+	lib_path?: string,
+): Src_Json =>
+	Src_Json.parse({
+		name: package_json.name,
+		version: package_json.version,
+		modules: to_src_modules(package_json.exports, log, lib_path),
+	});
+
+export const serialize_src_json = (src_json: Src_Json): string => {
+	const parsed = Src_Json.parse(src_json); // TODO can parse do the logic that normalize does? see `.transform`
+	return JSON.stringify(parsed, null, 2) + '\n';
+};
+
+export const to_src_modules = (
+	exports: Package_Json_Exports | undefined,
+	log?: Logger,
+	lib_path = paths.lib,
+): Src_Modules | undefined => {
+	if (!exports) return;
+
+	const project = new Project();
+	project.addSourceFilesAtPaths('src/**/*.ts'); // TODO dir? maybe rewrite with `lib_path`?
+
+	return Object.fromEntries(
+		Object.entries(exports)
+			.map(([k, _v]) => {
+				// TODO hacky - doesn't handle any but the normal mappings, also add a helper?
+				const source_file_path =
+					k === '.' || k === './'
+						? 'index.ts'
+						: strip_start(k.endsWith('.js') ? replace_extension(k, '.ts') : k, './');
+				if (!source_file_path.endsWith('.ts')) {
+					// TODO support more than just TypeScript - maybe use @sveltejs/language-tools,
+					// see how @sveltejs/package generates types, or maybe use its generated declaration files with ts-morph
+					const src_module: Src_Module = {path: source_file_path, declarations: []};
+					return [k, src_module];
+				}
+				const source_file_id = join(lib_path, source_file_path);
+				if (!existsSync(source_file_id)) {
+					log?.warn(
+						'failed to infer source file from export path',
+						k,
+						'- the inferred file',
+						source_file_id,
+						'does not exist',
+					);
+					return null;
+				}
+
+				const declarations: Src_Module_Declaration[] = [];
+
+				const source_file = project.getSourceFile((f) =>
+					f.getFilePath().endsWith(source_file_path),
+				); // TODO expected this to work without the callback, according to my read of the docs it is, but `project.getSourceFile(source_file_path)` fails
+				if (source_file) {
+					for (const [name, decls] of source_file.getExportedDeclarations()) {
+						// TODO how to correctly handle multiples?
+						for (const decl of decls) {
+							// TODO helper
+							const decl_type = decl.getType();
+							const k = decl.getKindName();
+							const kind =
+								k === 'InterfaceDeclaration' || k === 'TypeAliasDeclaration'
+									? 'type'
+									: k === 'ClassDeclaration'
+										? 'class'
+										: k === 'VariableDeclaration'
+											? decl_type.getCallSignatures().length
+												? 'function'
+												: 'variable' // TODO name?
+											: null;
+							// TODO
+							// const code =
+							// 	k === 'InterfaceDeclaration' || k === 'TypeAliasDeclaration'
+							// 		? decl_type.getText(source_file) // TODO
+							// 		: decl_type.getText(source_file);
+							const found = declarations.find((d) => d.name === name);
+							if (found) {
+								// TODO hacky, this only was added to prevent `TypeAliasDeclaration` from overriding `VariableDeclaration`
+								if (found.kind === 'type') {
+									found.kind = kind;
+									// found.code = code;
+								}
+							} else {
+								// TODO more
+								declarations.push({name, kind}); // code
+							}
+						}
+					}
+				}
+
+				const src_module: Src_Module = {path: source_file_path, declarations};
+				return [k, src_module];
+			})
+			.filter((v) => v !== null),
+	);
+};

package/src/lib/svelte_helpers.ts

@@ -0,0 +1,2 @@
+export const SVELTE_MATCHER = /\.svelte$/u;
+export const SVELTE_RUNES_MATCHER = /\.svelte\.(js|ts)$/u; // TODO probably let `.svelte.` appear anywhere - https://github.com/sveltejs/svelte/issues/11536

package/src/lib/sveltekit_config.ts

@@ -0,0 +1,101 @@
+import type {Config as SveltekitConfig} from '@sveltejs/kit';
+import type {CompileOptions, PreprocessorGroup, ModuleCompileOptions} from 'svelte/compiler';
+import {join} from 'node:path';
+
+import {SVELTEKIT_CONFIG_FILENAME} from './path_constants.js';
+
+/*
+
+This module is intended to have minimal dependencies to avoid over-imports in the CLI.
+
+*/
+
+/**
+ * Loads a SvelteKit config at `dir`.
+ * @returns `null` if no config is found
+ */
+export const load_sveltekit_config = async (
+	dir: string = process.cwd(),
+): Promise<SveltekitConfig | null> => {
+	try {
+		return (await import(join(dir, SVELTEKIT_CONFIG_FILENAME))).default;
+	} catch (_err) {
+		return null;
+	}
+};
+
+/**
+ * A subset of SvelteKit's config in a form that Gro uses
+ * because SvelteKit doesn't expose its config resolver.
+ * Flattens things out to keep them simple and easy to pass around,
+ * and doesn't deal with most properties.
+ * The `base` and `assets` in particular are renamed for clarity with Gro's internal systems,
+ * so these properties become first-class vocabulary inside Gro.
+ */
+export interface Parsed_Sveltekit_Config {
+	// TODO probably fill these out with defaults
+	sveltekit_config: SveltekitConfig | null;
+	alias: Record<string, string> | undefined;
+	base_url: '' | `/${string}` | undefined;
+	assets_url: '' | `http://${string}` | `https://${string}` | undefined;
+
+	// TODO others, but maybe replace with a Zod schema? https://kit.svelte.dev/docs/configuration
+	assets_path: string;
+	lib_path: string;
+	routes_path: string;
+
+	env_dir: string | undefined;
+	private_prefix: string | undefined;
+	public_prefix: string | undefined;
+	svelte_compile_options: CompileOptions;
+	svelte_compile_module_options: ModuleCompileOptions;
+	svelte_preprocessors: PreprocessorGroup | PreprocessorGroup[] | undefined;
+}
+
+// TODO currently incomplete and hack - maybe rethink
+/**
+ * Returns Gro-relevant properties of a SvelteKit config
+ * as a convenience wrapper around `load_sveltekit_config`.
+ * Needed because SvelteKit doesn't expose its config resolver.
+ */
+export const init_sveltekit_config = async (
+	dir_or_config: string | SveltekitConfig = process.cwd(),
+): Promise<Parsed_Sveltekit_Config> => {
+	const sveltekit_config =
+		typeof dir_or_config === 'string' ? await load_sveltekit_config(dir_or_config) : dir_or_config;
+	const kit = sveltekit_config?.kit;
+
+	const alias = kit?.alias;
+
+	const base_url = kit?.paths?.base;
+	const assets_url = kit?.paths?.assets;
+
+	// TODO probably a Zod schema instead
+	const assets_path = kit?.files?.assets ?? 'static';
+	const lib_path = kit?.files?.lib ?? 'src/lib';
+	const routes_path = kit?.files?.routes ?? 'src/routes';
+
+	const env_dir = kit?.env?.dir;
+	const private_prefix = kit?.env?.privatePrefix;
+	const public_prefix = kit?.env?.publicPrefix;
+
+	const svelte_compile_options = sveltekit_config?.compilerOptions ?? {};
+	const svelte_compile_module_options = {}; // TODO from `kit`? or subset of `svelte_compile_options`?
+	const svelte_preprocessors = sveltekit_config?.preprocess;
+
+	return {
+		sveltekit_config,
+		alias,
+		base_url,
+		assets_url,
+		assets_path,
+		lib_path,
+		routes_path,
+		env_dir,
+		private_prefix,
+		public_prefix,
+		svelte_compile_options,
+		svelte_compile_module_options,
+		svelte_preprocessors,
+	};
+};

package/src/lib/sveltekit_config_global.ts

@@ -0,0 +1,6 @@
+import {init_sveltekit_config} from './sveltekit_config.js';
+
+/**
+ * The parsed SvelteKit config for the cwd, cached globally at the module level.
+ */
+export const sveltekit_config_global = await init_sveltekit_config(); // always load it to keep things simple ahead

package/src/lib/sveltekit_helpers.ts

@@ -0,0 +1,132 @@
+import type {Result} from '@ryanatkn/belt/result.js';
+import {existsSync} from 'node:fs';
+
+import {Package_Json, load_package_json} from './package_json.js';
+import {sveltekit_config_global} from './sveltekit_config_global.js';
+import type {Parsed_Sveltekit_Config} from './sveltekit_config.js';
+import {SVELTEKIT_CONFIG_FILENAME, SVELTEKIT_DEV_DIRNAME} from './path_constants.js';
+import {find_cli, spawn_cli, to_cli_name, type Cli} from './cli.js';
+import {Task_Error} from './task.js';
+
+export const SVELTEKIT_CLI = 'svelte-kit';
+
+export const SVELTE_CHECK_CLI = 'svelte-check';
+
+export const SVELTE_PACKAGE_CLI = 'svelte-package';
+export const SVELTE_PACKAGE_DEP_NAME = '@sveltejs/package';
+
+export const VITE_CLI = 'vite';
+
+export const has_sveltekit_app = (): Result<object, {message: string}> => {
+	if (!existsSync(SVELTEKIT_CONFIG_FILENAME)) {
+		return {ok: false, message: `no SvelteKit config found at ${SVELTEKIT_CONFIG_FILENAME}`};
+	}
+	// TODO check for routes?
+	return {ok: true};
+};
+
+export const has_sveltekit_library = (
+	package_json?: Package_Json,
+	sveltekit_config: Parsed_Sveltekit_Config = sveltekit_config_global,
+): Result<object, {message: string}> => {
+	const has_sveltekit_app_result = has_sveltekit_app();
+	if (!has_sveltekit_app_result.ok) {
+		return has_sveltekit_app_result;
+	}
+
+	if (!existsSync(sveltekit_config.lib_path)) {
+		return {ok: false, message: `no SvelteKit lib directory found at ${sveltekit_config.lib_path}`};
+	}
+
+	const pkg = package_json ?? load_package_json();
+	if (
+		!(pkg.devDependencies?.[SVELTE_PACKAGE_DEP_NAME] || pkg.dependencies?.[SVELTE_PACKAGE_DEP_NAME])
+	) {
+		return {
+			ok: false,
+			message: `no dependency found in package.json for ${SVELTE_PACKAGE_DEP_NAME}, install it with \`npm i -D ${SVELTE_PACKAGE_DEP_NAME}\``,
+		};
+	}
+
+	return {ok: true};
+};
+
+export const sveltekit_sync = async (
+	sveltekit_cli: string | Cli = SVELTEKIT_CLI,
+): Promise<void> => {
+	const result = await spawn_cli(sveltekit_cli, ['sync']);
+	if (!result) {
+		throw new Task_Error(
+			`Failed to find SvelteKit CLI \`${to_cli_name(sveltekit_cli)}\`, do you need to run \`npm i\`?`,
+		);
+	} else if (!result.ok) {
+		throw new Task_Error(`Failed ${to_cli_name(sveltekit_cli)} sync`);
+	}
+};
+
+/**
+ * If the SvelteKit CLI is found and its `.svelte-kit` directory is not, run `svelte-kit sync`.
+ */
+export const sveltekit_sync_if_obviously_needed = async (
+	sveltekit_cli: string | Cli = SVELTEKIT_CLI,
+): Promise<void> => {
+	if (existsSync(SVELTEKIT_DEV_DIRNAME)) {
+		return;
+	}
+	const found_sveltekit_cli =
+		typeof sveltekit_cli === 'string' ? find_cli(sveltekit_cli) : sveltekit_cli;
+	if (!found_sveltekit_cli) {
+		return;
+	}
+	return sveltekit_sync(found_sveltekit_cli);
+};
+
+/**
+ * Options to the SvelteKit packaging CLI.
+ * @see https://kit.svelte.dev/docs/packaging#options
+ */
+export interface Svelte_Package_Options {
+	/**
+	 * Watch files in src/lib for changes and rebuild the package
+	 */
+	watch?: boolean;
+	/**
+	 * Alias for `watch`.
+	 */
+	w?: boolean;
+	/**
+	 * The input directory which contains all the files of the package.
+	 * Defaults to src/lib
+	 */
+	input?: string;
+	/**
+	 * Alias for `input`.
+	 */
+	i?: string;
+	/**
+	 * The output directory where the processed files are written to.
+	 * Your package.json's exports should point to files inside there,
+	 * and the files array should include that folder.
+	 * Defaults to dist
+	 */
+	output?: string;
+	/**
+	 * Alias for `output`.
+	 */
+	o?: string;
+	/**
+	 * Whether or not to create type definitions (d.ts files).
+	 * We strongly recommend doing this as it fosters ecosystem library quality.
+	 * Defaults to true
+	 */
+	types?: boolean;
+	/**
+	 * Alias for `types`.
+	 */
+	t?: boolean;
+	/**
+	 * The path to a tsconfig or jsconfig.
+	 * When not provided, searches for the next upper tsconfig/jsconfig in the workspace path.
+	 */
+	tsconfig?: string;
+}

package/src/lib/sveltekit_shim_app.ts

@@ -0,0 +1,42 @@
+import type {Parsed_Sveltekit_Config} from './sveltekit_config.js';
+
+export const SVELTEKIT_SHIM_APP_PATHS_MATCHER = /\/util\/sveltekit_shim_app_paths\.js$/u;
+export const SVELTEKIT_SHIM_APP_ENVIRONMENT_MATCHER =
+	/\/util\/sveltekit_shim_app_environment\.js$/u;
+
+/**
+ * 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', '@ryanatkn/gro/sveltekit_shim_app_environment.js'],
+	['$app/forms', '@ryanatkn/gro/sveltekit_shim_app_forms.js'],
+	['$app/navigation', '@ryanatkn/gro/sveltekit_shim_app_navigation.js'],
+	['$app/paths', '@ryanatkn/gro/sveltekit_shim_app_paths.js'],
+	['$app/stores', '@ryanatkn/gro/sveltekit_shim_app_stores.js'],
+]);
+
+export const render_sveltekit_shim_app_paths = (
+	base_url: Parsed_Sveltekit_Config['base_url'] = '',
+	assets_url: Parsed_Sveltekit_Config['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,14 @@
+// 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
+ */
+
+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,20 @@
+// 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 '@ryanatkn/belt/function.js';
+import * as devalue from 'devalue';
+
+export const applyAction: typeof base_applyAction = noop_async;
+export const deserialize: typeof base_deserialize = (result) => {
+	const parsed = JSON.parse(result);
+	if (parsed.data) {
+		parsed.data = devalue.parse(parsed.data);
+	}
+	return parsed;
+};
+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 '@ryanatkn/belt/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,16 @@
+// 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
+ */
+
+import type {resolveRoute as base_resolveRoute} from '$app/paths';
+import {noop} from '@ryanatkn/belt/function.js';
+
+export const assets = '';
+export const base = '';
+export const resolveRoute: typeof base_resolveRoute = noop;

package/src/lib/sveltekit_shim_app_stores.ts

@@ -0,0 +1,25 @@
+// shim for $app/stores
+// @see https://github.com/sveltejs/kit/issues/1485
+
+import type {
+	getStores as base_getStores,
+	navigating as base_navigating,
+	page as base_page,
+	updated as base_updated,
+} from '$app/stores';
+import {readable} from 'svelte/store';
+
+export const getStores: typeof base_getStores = () => ({navigating, page, updated}) as const;
+export const navigating: typeof base_navigating = readable(null);
+export const page: typeof base_page = readable({
+	url: new URL('https://gro.ryanatkn.com/TODO'),
+	params: {},
+	route: {id: 'RouteId'},
+	status: 200,
+	error: null,
+	data: {},
+	state: {},
+	form: {},
+});
+export const updated: typeof base_updated = readable(true) as any;
+updated.check = () => Promise.resolve(true);