@ryanatkn/gro 0.112.0

package/dist/input_path.js

@@ -0,0 +1,161 @@
+import { join, isAbsolute, basename } from 'node:path';
+import { strip_end, strip_start } from '@ryanatkn/belt/string.js';
+import { stat } from 'node:fs/promises';
+import { lib_path_to_import_id, replace_root_dir, gro_dir_basename, gro_paths, LIB_DIR, LIB_PATH, is_this_project_gro, gro_sveltekit_dist_dir, paths, } from './paths.js';
+import { to_path_data } from './path.js';
+import { exists } from './fs.js';
+import { search_fs } from './search_fs.js';
+/**
+ * Raw input paths are paths that users provide to Gro to reference files
+ * enhanced with Gro's conventions like `.test.`, `.task.`, and `.gen.`.
+ *
+ * A raw input path can be:
+ *
+ * - a relative path to a file, e.g. `src/foo/bar.test.ts`
+ * - a file without an extension, e.g. `src/foo/bar` if `extensions` is `.test.ts`
+ * - a directory containing any number of files, e.g. `src/foo`
+ * - any of the above without the leading `src/` or with a leading `./`
+ * - any of the above but leading with `gro/` to ignore the local directory
+ * - an absolute path to a file or directory in the current directory or Gro's
+ *
+ * The input path API lets the caller customize the allowable extensions.
+ * That means that the caller can look for `.test.` files but not `.gen.`,
+ * or both, or neither, depending on its needs.
+ *
+ * In the future we may want to support globbing or regexps.
+ */
+export const resolve_input_path = (raw_input_path) => {
+    if (isAbsolute(raw_input_path))
+        return strip_end(raw_input_path, '/');
+    // Allow prefix `./` and just remove it if it's there.
+    let base_path = strip_end(strip_start(raw_input_path, './'), '/');
+    let paths;
+    // If it's prefixed with `gro/` or exactly `gro`, use the Gro paths.
+    if (is_this_project_gro || (base_path + '/').startsWith(gro_dir_basename)) {
+        paths = gro_paths;
+        base_path = strip_end(strip_start(base_path + '/', gro_dir_basename), '/');
+    }
+    // Handle `src/lib` by itself without conflicting with `src/libFoo` names.
+    if (base_path === LIB_PATH)
+        base_path = ''; // TODO @multiple get from the sveltekit config
+    // Allow prefix `src/lib/` and just remove it if it's there.
+    base_path = strip_start(base_path, LIB_DIR);
+    return lib_path_to_import_id(base_path, paths);
+};
+export const resolve_input_paths = (raw_input_paths) => raw_input_paths?.length ? raw_input_paths.map((p) => resolve_input_path(p)) : [paths.source];
+/**
+ * Gets a list of possible source ids for each input path with `extensions`,
+ * duplicating each under `root_dirs`.
+ * This is first used to fall back to the Gro dir to search for tasks.
+ * It's the helper used in implementations of `get_possible_source_ids_for_input_path` below.
+ */
+export const get_possible_source_ids = (input_path, extensions, root_dirs) => {
+    const possible_source_ids = [input_path];
+    if (!input_path.endsWith('/')) {
+        for (const extension of extensions) {
+            if (!input_path.endsWith(extension)) {
+                possible_source_ids.push(input_path + extension);
+                // Support task directories, so `src/lib/a/a.task.ts` works like `src/a.task.ts`.
+                possible_source_ids.push(join(input_path, basename(input_path) + extension));
+            }
+        }
+    }
+    if (root_dirs?.length) {
+        const ids = possible_source_ids.slice(); // make a copy or infinitely loop!
+        for (const root_dir of root_dirs) {
+            if (input_path.startsWith(root_dir))
+                continue; // avoid duplicates
+            const is_gro_dist = root_dir === gro_sveltekit_dist_dir; // TODO hacky to handle Gro importing its JS tasks from dist/
+            for (const possible_source_id of ids) {
+                if (is_gro_dist && !possible_source_id.endsWith('.js'))
+                    continue;
+                // TODO hacky to handle Gro importing its JS tasks from dist/
+                possible_source_ids.push(is_gro_dist
+                    ? gro_sveltekit_dist_dir + strip_start(possible_source_id, paths.lib)
+                    : replace_root_dir(possible_source_id, root_dir, paths));
+            }
+        }
+    }
+    return possible_source_ids;
+};
+/**
+ * Gets the path data for each input path,
+ * searching for the possibilities based on `extensions`
+ * and stopping at the first match.
+ * Parameterized by `exists` and `stat` so it's fs-agnostic.
+ */
+export const load_source_path_data_by_input_path = async (input_paths, get_possible_source_ids_for_input_path) => {
+    const source_id_path_data_by_input_path = new Map();
+    const unmapped_input_paths = [];
+    for (const input_path of input_paths) {
+        let file_path_data = null;
+        let dir_path_data = null;
+        const possible_source_ids = get_possible_source_ids_for_input_path
+            ? get_possible_source_ids_for_input_path(input_path)
+            : [input_path];
+        for (const possible_source_id of possible_source_ids) {
+            if (!(await exists(possible_source_id)))
+                continue; // eslint-disable-line no-await-in-loop
+            const stats = await stat(possible_source_id); // eslint-disable-line no-await-in-loop
+            if (stats.isDirectory()) {
+                if (!dir_path_data) {
+                    dir_path_data = to_path_data(possible_source_id, stats);
+                }
+            }
+            else {
+                file_path_data = to_path_data(possible_source_id, stats);
+                break;
+            }
+        }
+        if (file_path_data || dir_path_data) {
+            source_id_path_data_by_input_path.set(input_path, file_path_data || dir_path_data); // the ! is needed because TypeScript inference fails
+        }
+        else {
+            unmapped_input_paths.push(input_path);
+        }
+    }
+    return { source_id_path_data_by_input_path, unmapped_input_paths };
+};
+/**
+ * Finds all of the matching files for the given input paths.
+ * Parameterized by `find_files` so it's fs-agnostic.
+ * De-dupes source ids.
+ */
+export const load_source_ids_by_input_path = async (source_id_path_data_by_input_path, custom_search_fs = search_fs) => {
+    const source_ids_by_input_path = new Map();
+    const input_directories_with_no_files = [];
+    const existing_source_ids = new Set();
+    for (const [input_path, path_data] of source_id_path_data_by_input_path) {
+        const { id } = path_data;
+        if (path_data.isDirectory) {
+            const files = await custom_search_fs(id, { files_only: false }); // eslint-disable-line no-await-in-loop
+            if (files.size) {
+                const source_ids = [];
+                let has_files = false;
+                for (const path of files.keys()) {
+                    has_files = true;
+                    const source_id = join(id, path);
+                    if (!existing_source_ids.has(source_id)) {
+                        existing_source_ids.add(source_id);
+                        source_ids.push(source_id);
+                    }
+                }
+                if (source_ids.length) {
+                    source_ids_by_input_path.set(input_path, source_ids);
+                }
+                if (!has_files) {
+                    input_directories_with_no_files.push(input_path);
+                }
+                // do callers ever need `inputDirectoriesWithDuplicateFiles`?
+            }
+            else {
+                input_directories_with_no_files.push(input_path);
+            }
+        }
+        else if (!existing_source_ids.has(id)) {
+            existing_source_ids.add(id);
+            source_ids_by_input_path.set(input_path, [id]);
+        }
+    }
+    return { source_ids_by_input_path, input_directories_with_no_files };
+};

package/dist/input_path.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/input_path.test.js

@@ -0,0 +1,106 @@
+import { suite } from 'uvu';
+import * as assert from 'uvu/assert';
+import { resolve } from 'node:path';
+import { resolve_input_path, resolve_input_paths, load_source_ids_by_input_path, get_possible_source_ids, } from './input_path.js';
+import { paths } from './paths.js';
+/* test__resolve_input_path */
+const test__resolve_input_path = suite('resolve_input_path');
+test__resolve_input_path('basic behavior', () => {
+    const target = resolve('dist/foo/bar.ts');
+    assert.is(resolve_input_path('foo/bar.ts'), target);
+    assert.is(resolve_input_path('src/lib/foo/bar.ts'), target);
+    assert.is(resolve_input_path('./src/lib/foo/bar.ts'), target);
+    assert.is(resolve_input_path('./foo/bar.ts'), target); // questionable
+    assert.is(resolve_input_path(target), target);
+    assert.is.not(resolve_input_path('bar.ts'), target);
+});
+test__resolve_input_path('directories', () => {
+    const target_dir = resolve('dist/foo/bar');
+    assert.is(resolve_input_path('foo/bar'), target_dir);
+    assert.is(resolve_input_path('foo/bar/'), target_dir);
+    assert.is(resolve_input_path('./foo/bar'), target_dir);
+    assert.is(resolve_input_path('./foo/bar/'), target_dir);
+    assert.is.not(resolve_input_path('bar'), target_dir);
+});
+test__resolve_input_path.run();
+/* test__resolve_input_path */
+/* test__resolve_input_paths */
+const test__resolve_input_paths = suite('resolve_input_paths');
+test__resolve_input_paths('resolves multiple input path forms', () => {
+    assert.equal(resolve_input_paths(['foo/bar.ts', 'baz', './']), [
+        resolve('dist/foo/bar.ts'),
+        resolve('dist/baz'),
+        resolve('dist') + '/',
+    ]);
+});
+test__resolve_input_paths.run();
+/* test__resolve_input_paths */
+/* test__get_possible_source_ids */
+const test__get_possible_source_ids = suite('get_possible_source_ids');
+test__get_possible_source_ids('in the gro directory', () => {
+    const input_path = resolve('src/foo/bar');
+    assert.equal(get_possible_source_ids(input_path, ['.baz.ts']), [
+        input_path,
+        input_path + '.baz.ts',
+        input_path + '/bar.baz.ts',
+    ]);
+});
+test__get_possible_source_ids('does not repeat the extension', () => {
+    const input_path = resolve('src/foo/bar.baz.ts');
+    assert.equal(get_possible_source_ids(input_path, ['.baz.ts']), [input_path]);
+});
+test__get_possible_source_ids('does not repeat with the same root directory', () => {
+    const input_path = resolve('src/foo/bar.baz.ts');
+    assert.equal(get_possible_source_ids(input_path, ['.baz.ts'], [paths.root, paths.root]), [
+        input_path,
+    ]);
+});
+test__get_possible_source_ids('implied to be a directory by trailing slash', () => {
+    const input_path = resolve('src/foo/bar') + '/';
+    assert.equal(get_possible_source_ids(input_path, ['.baz.ts']), [input_path]);
+});
+test__get_possible_source_ids.run();
+/* test__get_possible_source_ids */
+/* test__load_source_ids_by_input_path */
+const test__load_source_ids_by_input_path = suite('load_source_ids_by_input_path', async () => {
+    const test_files = {
+        'fake/test1.bar.ts': new Map([['fake/test1.bar.ts', { isDirectory: () => false }]]),
+        'fake/test2.bar.ts': new Map([['fake/test2.bar.ts', { isDirectory: () => false }]]),
+        'fake/test3': new Map([
+            ['fake/test3', { isDirectory: () => true }],
+            ['a.ts', { isDirectory: () => false }],
+            ['b.ts', { isDirectory: () => false }],
+        ]),
+        // duplicate
+        'fake/': new Map([
+            ['fake/test3', { isDirectory: () => true }],
+            ['test3/a.ts', { isDirectory: () => false }],
+        ]),
+        // duplicate and not
+        fake: new Map([
+            ['fake/test3', { isDirectory: () => true }],
+            ['test3/a.ts', { isDirectory: () => false }],
+            ['test3/c.ts', { isDirectory: () => false }],
+        ]),
+        'fake/nomatches': new Map([['fake/nomatches', { isDirectory: () => true }]]),
+    };
+    const result = await load_source_ids_by_input_path(new Map([
+        ['fake/test1.bar.ts', { id: 'fake/test1.bar.ts', isDirectory: false }],
+        ['fake/test2', { id: 'fake/test2.bar.ts', isDirectory: false }],
+        ['fake/test3', { id: 'fake/test3', isDirectory: true }],
+        ['fake/', { id: 'fake/', isDirectory: true }],
+        ['fake', { id: 'fake', isDirectory: true }],
+        ['fake/nomatches', { id: 'fake/nomatches', isDirectory: true }],
+    ]), async (id) => test_files[id]);
+    assert.equal(result, {
+        source_ids_by_input_path: new Map([
+            ['fake/test1.bar.ts', ['fake/test1.bar.ts']],
+            ['fake/test2', ['fake/test2.bar.ts']],
+            ['fake/test3', ['fake/test3/a.ts', 'fake/test3/b.ts']],
+            ['fake', ['fake/test3/c.ts']],
+        ]),
+        input_directories_with_no_files: ['fake/nomatches'],
+    });
+});
+test__load_source_ids_by_input_path.run();
+/* test__load_source_ids_by_input_path */

package/dist/invoke.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/invoke.js

@@ -0,0 +1,18 @@
+import { attach_process_error_handlers } from '@ryanatkn/belt/process.js';
+import { invoke_task } from './invoke_task.js';
+import { to_task_args } from './args.js';
+import { load_config } from './config.js';
+/*
+
+This module invokes the Gro CLI which in turn invokes tasks.
+Tasks are the CLI's primary concept.
+To learn more about them, see `src/lib/docs/task.md`.
+
+When the CLI is invoked it passes the first CLI arg as `task_name` to `invoke_task`,
+and the rest of the args are forwarded to the task's `run` function.
+
+*/
+// handle uncaught errors
+attach_process_error_handlers((err) => err?.constructor?.name === 'Task_Error' ? 'Task_Error' : null);
+const { task_name, args } = to_task_args();
+await invoke_task(task_name, args, await load_config());

package/dist/invoke_task.d.ts

@@ -0,0 +1,20 @@
+import { type Args } from './args.js';
+import type { Gro_Config } from './config.js';
+/**
+ * Invokes Gro tasks by name using the filesystem as the source.
+ *
+ * When a task is invoked,
+ * Gro first searches for tasks in the current working directory.
+ * and falls back to searching Gro's directory, if the two are different.
+ * See `src/lib/input_path.ts` for info about what "task_name" can refer to.
+ * If it matches a directory, all of the tasks within it are logged,
+ * both in the current working directory and Gro.
+ *
+ * This code is particularly hairy because
+ * we're accepting a wide range of user input
+ * and trying to do the right thing.
+ * Precise error messages are especially difficult and
+ * there are some subtle differences in the complex logical branches.
+ * The comments describe each condition.
+ */
+export declare const invoke_task: (task_name: string, args: Args, config: Gro_Config, timings?: any) => Promise<void>;

package/dist/invoke_task.js

@@ -0,0 +1,140 @@
+import { cyan, red, gray } from 'kleur/colors';
+import { Logger, System_Logger, print_log_label } from '@ryanatkn/belt/log.js';
+import { create_stopwatch, Timings } from '@ryanatkn/belt/timings.js';
+import { print_ms, print_timings } from '@ryanatkn/belt/print.js';
+import { to_forwarded_args } from './args.js';
+import { run_task } from './run_task.js';
+import { resolve_input_path } from './input_path.js';
+import { is_task_path } from './task.js';
+import { is_gro_id, is_this_project_gro, print_path, print_path_or_gro_path, gro_sveltekit_dist_dir, to_gro_input_path, } from './paths.js';
+import { find_modules, load_modules } from './modules.js';
+import { find_task_modules, load_task_module } from './task_module.js';
+import { load_gro_package_json } from './package_json.js';
+import { log_available_tasks, log_error_reasons } from './print_task.js';
+import { search_fs } from './search_fs.js';
+/**
+ * Invokes Gro tasks by name using the filesystem as the source.
+ *
+ * When a task is invoked,
+ * Gro first searches for tasks in the current working directory.
+ * and falls back to searching Gro's directory, if the two are different.
+ * See `src/lib/input_path.ts` for info about what "task_name" can refer to.
+ * If it matches a directory, all of the tasks within it are logged,
+ * both in the current working directory and Gro.
+ *
+ * This code is particularly hairy because
+ * we're accepting a wide range of user input
+ * and trying to do the right thing.
+ * Precise error messages are especially difficult and
+ * there are some subtle differences in the complex logical branches.
+ * The comments describe each condition.
+ */
+export const invoke_task = async (task_name, args, config, timings = new Timings()) => {
+    const log = new System_Logger(print_log_label(task_name || 'gro'));
+    log.info('invoking', task_name ? cyan(task_name) : 'gro');
+    const total_timing = create_stopwatch();
+    // Check if the caller just wants to see the version.
+    if (!task_name && (args.version || args.v)) {
+        const gro_package_json = await load_gro_package_json();
+        log.info(`${gray('v')}${cyan(gro_package_json.version)}`);
+        log.info(`🕒 ${print_ms(total_timing())}`);
+        return;
+    }
+    // Resolve the input path for the provided task name.
+    const input_path = resolve_input_path(task_name);
+    // Find the task or directory specified by the `input_path`.
+    // Fall back to searching the Gro directory as well.
+    const find_modules_result = await find_task_modules([input_path], undefined, [
+        gro_sveltekit_dist_dir,
+    ]);
+    if (find_modules_result.ok) {
+        // Found a match either in the current working directory or Gro's directory.
+        const path_data = find_modules_result.source_id_path_data_by_input_path.get(input_path); // this is null safe because result is ok
+        if (!path_data.isDirectory) {
+            // The input path matches a file, so load and run it.
+            // Try to load the task module.
+            const load_modules_result = await load_modules(find_modules_result.source_ids_by_input_path, load_task_module);
+            if (load_modules_result.ok) {
+                // We found a task module. Run it!
+                // `path_data` is not a directory, so there's a single task module here.
+                const task = load_modules_result.modules[0];
+                log.info(`→ ${cyan(task.name)} ${(task.mod.task.summary && gray(task.mod.task.summary)) || ''}`);
+                const timing_to_run_task = timings.start('run task ' + task_name);
+                const result = await run_task(task, { ...args, ...to_forwarded_args(`gro ${task.name}`) }, invoke_task, config, timings);
+                timing_to_run_task();
+                if (result.ok) {
+                    log.info(`✓ ${cyan(task.name)}`);
+                }
+                else {
+                    log.info(`${red('🞩')} ${cyan(task.name)}`);
+                    log_error_reasons(log, [result.reason]);
+                    throw result.error;
+                }
+            }
+            else {
+                log_error_reasons(log, load_modules_result.reasons);
+                process.exit(1);
+            }
+        }
+        else {
+            // The input path matches a directory. Log the tasks but don't run them.
+            if (is_this_project_gro) {
+                // Is the Gro directory the same as the cwd? Log the matching files.
+                await log_available_tasks(log, print_path(path_data.id), find_modules_result.source_ids_by_input_path);
+            }
+            else if (is_gro_id(path_data.id)) {
+                // TODO delete this?
+                // Does the Gro directory contain the matching files? Log them.
+                await log_available_tasks(log, print_path_or_gro_path(path_data.id), find_modules_result.source_ids_by_input_path);
+            }
+            else {
+                // The Gro directory is not the same as the cwd
+                // and it doesn't contain the matching files.
+                // Find all of the possible matches in the Gro directory as well,
+                // and log everything out.
+                // Ignore any errors - the directory may not exist or have any files!
+                const gro_dir_find_modules_result = await to_gro_dir_find_modules_result(input_path, log);
+                // Then log the current working directory matches.
+                await log_available_tasks(log, print_path(path_data.id), find_modules_result.source_ids_by_input_path, !gro_dir_find_modules_result.ok);
+            }
+        }
+    }
+    else if (find_modules_result.type === 'input_directories_with_no_files') {
+        // The input path matched a directory, but it contains no matching files.
+        if (is_this_project_gro ||
+            // this is null safe because of the failure type
+            is_gro_id(find_modules_result.source_id_path_data_by_input_path.get(input_path).id)) {
+            // If the directory is inside Gro, just log the errors.
+            log_error_reasons(log, find_modules_result.reasons);
+            process.exit(1);
+        }
+        else {
+            // If there's a matching directory in the current working directory,
+            // but it has no matching files, we still want to search Gro's directory.
+            const gro_dir_find_modules_result = await to_gro_dir_find_modules_result(input_path, log);
+            if (!gro_dir_find_modules_result.ok) {
+                // Log the original errors, not the Gro-specific ones.
+                log_error_reasons(log, find_modules_result.reasons);
+                process.exit(1);
+            }
+        }
+    }
+    else {
+        // Some other find modules result failure happened, so log it out.
+        // (currently, just "unmapped_input_paths")
+        log_error_reasons(log, find_modules_result.reasons);
+        process.exit(1);
+    }
+    print_timings(timings, log);
+    log.info(`🕒 ${print_ms(total_timing())}`);
+};
+const to_gro_dir_find_modules_result = async (input_path, log) => {
+    const gro_dir_input_path = to_gro_input_path(input_path);
+    const gro_dir_find_modules_result = await find_modules([gro_dir_input_path], (id) => search_fs(id, { filter: (path) => is_task_path(path) }));
+    if (gro_dir_find_modules_result.ok) {
+        const gro_path_data = gro_dir_find_modules_result.source_id_path_data_by_input_path.get(gro_dir_input_path);
+        // Log the Gro matches.
+        await log_available_tasks(log, print_path_or_gro_path(gro_path_data.id), gro_dir_find_modules_result.source_ids_by_input_path);
+    }
+    return gro_dir_find_modules_result;
+};

package/dist/lint.task.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { type Task } from './task.js';
+export declare const Args: z.ZodObject<{
+    _: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    _: string[];
+}, {
+    _?: string[] | undefined;
+}>;
+export type Args = z.infer<typeof Args>;
+export declare const task: Task<Args>;

package/dist/lint.task.js

@@ -0,0 +1,29 @@
+import { print_spawn_result } from '@ryanatkn/belt/process.js';
+import { z } from 'zod';
+import { Task_Error } from './task.js';
+import { print_command_args, serialize_args, to_forwarded_args } from './args.js';
+import { SOURCE_DIRNAME } from './paths.js';
+import { find_cli, spawn_cli } from './cli.js';
+export const Args = z
+    .object({
+    _: z.array(z.string(), { description: 'paths to serve' }).default([SOURCE_DIRNAME]),
+})
+    .strict();
+export const task = {
+    summary: 'run eslint',
+    Args,
+    run: async ({ log, args }) => {
+        if (!(await find_cli('eslint'))) {
+            log.info('ESLint is not installed; skipping linting');
+            return;
+        }
+        const { _ } = args;
+        const forwarded_args = { _, 'max-warnings': 0, ...to_forwarded_args('eslint') };
+        const serialized_args = serialize_args(forwarded_args);
+        log.info(print_command_args(['eslint'].concat(serialized_args)));
+        const eslintResult = await spawn_cli('eslint', serialized_args);
+        if (!eslintResult?.ok) {
+            throw new Task_Error(`ESLint found some problems. ${print_spawn_result(eslintResult)}`);
+        }
+    },
+};

package/dist/loader.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+import type { LoadHook, ResolveHook } from 'node:module';
+export declare const load: LoadHook;
+export declare const resolve: ResolveHook;

package/dist/loader.js

@@ -0,0 +1,153 @@
+import * as esbuild from 'esbuild';
+import { compile, preprocess } from 'svelte/compiler';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { dirname, join, relative } from 'node:path';
+import { escape_regexp } from '@ryanatkn/belt/regexp.js';
+import { render_env_shim_module } from './sveltekit_shim_env.js';
+import { render_sveltekit_shim_app_environment, render_sveltekit_shim_app_paths, sveltekit_shim_app_environment_matcher, sveltekit_shim_app_paths_matcher, sveltekit_shim_app_specifiers, } from './sveltekit_shim_app.js';
+import { init_sveltekit_config } from './sveltekit_config.js';
+import { paths, NODE_MODULES_DIRNAME } from './paths.js';
+import { to_define_import_meta_env, ts_transform_options } from './esbuild_helpers.js';
+import { resolve_specifier } from './resolve_specifier.js';
+import { resolve_node_specifier } from './resolve_node_specifier.js';
+/*
+
+Usage via `$lib/run.task.ts`:
+
+```bash
+gro run foo.ts
+```
+
+Direct usage (see also `$lib/gro.ts`):
+
+```bash
+node --import 'data:text/javascript,import {register} from "node:module"; import {pathToFileURL} from "node:url"; register("@ryanatkn/gro/loader.js", pathToFileURL("./"));' --enable-source-maps' foo.ts
+```
+
+TODO how to improve that gnarly import line? was originally designed for the now-deprecated `--loader`
+
+*/
+// TODO sourcemaps for svelte and the svelte preprocessors
+// TODO `import.meta.resolve` wasn't available in loaders when this was first implemented, but might be now
+// dev is always true in the loader
+const dev = true;
+const dir = paths.root;
+const { alias, base_url, assets_url, env_dir, private_prefix, public_prefix, svelte_compile_options, svelte_preprocessors, } = await init_sveltekit_config(dir); // always load it to keep things simple ahead
+const final_ts_transform_options = {
+    ...ts_transform_options,
+    define: to_define_import_meta_env(dev, base_url),
+    sourcemap: 'inline',
+};
+const aliases = Object.entries({ $lib: 'src/lib', ...alias });
+const ts_matcher = /\.(ts|tsx|mts|cts)$/u;
+const svelte_matcher = /\.(svelte)$/u;
+const json_matcher = /\.(json)$/u;
+const env_matcher = /src\/lib\/\$env\/(static|dynamic)\/(public|private)$/u;
+const node_modules_matcher = new RegExp(escape_regexp('/' + NODE_MODULES_DIRNAME + '/'), 'u');
+const package_json_cache = {};
+export const load = async (url, context, nextLoad) => {
+    if (sveltekit_shim_app_paths_matcher.test(url)) {
+        // $app/paths shim
+        return {
+            format: 'module',
+            shortCircuit: true,
+            source: render_sveltekit_shim_app_paths(base_url, assets_url),
+        };
+    }
+    else if (sveltekit_shim_app_environment_matcher.test(url)) {
+        // $app/environment shim
+        return {
+            format: 'module',
+            shortCircuit: true,
+            source: render_sveltekit_shim_app_environment(dev),
+        };
+    }
+    else if (ts_matcher.test(url)) {
+        // ts
+        const loaded = await nextLoad(url, context.format === 'module' ? context : { ...context, format: 'module' });
+        const transformed = await esbuild.transform(loaded.source.toString(), // eslint-disable-line @typescript-eslint/no-base-to-string
+        { ...final_ts_transform_options, sourcefile: url });
+        return { format: 'module', shortCircuit: true, source: transformed.code };
+    }
+    else if (svelte_matcher.test(url)) {
+        // svelte
+        // TODO support sourcemaps
+        const loaded = await nextLoad(url, context.format === 'module' ? context : { ...context, format: 'module' });
+        const raw_source = loaded.source.toString(); // eslint-disable-line @typescript-eslint/no-base-to-string
+        const preprocessed = svelte_preprocessors
+            ? await preprocess(raw_source, svelte_preprocessors, {
+                filename: relative(dir, fileURLToPath(url)),
+            })
+            : null;
+        const source = preprocessed?.code ?? raw_source;
+        const transformed = compile(source, svelte_compile_options);
+        return { format: 'module', shortCircuit: true, source: transformed.js.code };
+    }
+    else if (json_matcher.test(url)) {
+        // json
+        // TODO probably follow esbuild and also export every top-level property for objects from the module - https://esbuild.github.io/content-types/#json (type generation?)
+        const loaded = await nextLoad(url);
+        const raw_source = loaded.source.toString(); // eslint-disable-line @typescript-eslint/no-base-to-string
+        const source = `export default ` + raw_source;
+        return { format: 'module', shortCircuit: true, source };
+    }
+    else {
+        // neither ts nor svelte
+        const matched_env = env_matcher.exec(url);
+        if (matched_env) {
+            const mode = matched_env[1];
+            const visibility = matched_env[2];
+            return {
+                format: 'module',
+                shortCircuit: true,
+                source: await render_env_shim_module(dev, mode, visibility, public_prefix, private_prefix, env_dir),
+            };
+        }
+    }
+    return nextLoad(url, context);
+};
+export const resolve = async (specifier, context, nextResolve) => {
+    if (specifier === '$env/static/public' ||
+        specifier === '$env/static/private' ||
+        specifier === '$env/dynamic/public' ||
+        specifier === '$env/dynamic/private') {
+        // The returned `url` is validated before `load` is called,
+        // so we need a slightly roundabout strategy to pass through the specifier for virtual files.
+        return {
+            url: pathToFileURL(join(dir, 'src/lib', specifier)).href,
+            format: 'module',
+            shortCircuit: true,
+        };
+    }
+    const parent_url = context.parentURL;
+    if (!parent_url || node_modules_matcher.test(parent_url)) {
+        return nextResolve(specifier, context);
+    }
+    const shimmed = sveltekit_shim_app_specifiers.get(specifier);
+    if (shimmed !== undefined) {
+        return nextResolve(shimmed, context);
+    }
+    let path = specifier;
+    // Map the path with the SvelteKit aliases.
+    for (const [from, to] of aliases) {
+        if (path.startsWith(from)) {
+            path = join(dir, to, path.substring(from.length));
+            break;
+        }
+    }
+    // The specifier `path` has now been mapped to its final form, so we can inspect it.
+    if (path[0] !== '.' && path[0] !== '/') {
+        // Resolve to `node_modules`.
+        if (svelte_matcher.test(path) || json_matcher.test(path)) {
+            // Match the behavior of Vite and esbuild for Svelte and JSON imports.
+            // TODO maybe `.ts` too
+            const source_id = await resolve_node_specifier(path, dir, parent_url, package_json_cache);
+            return { url: pathToFileURL(source_id).href, format: 'module', shortCircuit: true };
+        }
+        else {
+            return nextResolve(path, context);
+        }
+    }
+    const { source_id } = await resolve_specifier(path, dirname(fileURLToPath(parent_url)));
+    return { url: pathToFileURL(source_id).href, format: 'module', shortCircuit: true };
+};

package/dist/module.d.ts

@@ -0,0 +1,3 @@
+export declare const MODULE_PATH_SRC_PREFIX: string;
+export declare const MODULE_PATH_LIB_PREFIX = "$lib/";
+export declare const is_external_module: (module_name: string) => boolean;