@ryanatkn/gro 0.135.2 → 0.136.0

package/dist/check.task.d.ts

@@ -22,6 +22,7 @@ export declare const Args: z.ZodObject<{
     sync: boolean;
     package_json: boolean;
     format: boolean;
+    gen: boolean;
     'no-sync': boolean;
     install: boolean;
     'no-install': boolean;
@@ -29,7 +30,6 @@ export declare const Args: z.ZodObject<{
     'no-typecheck': boolean;
     test: boolean;
     'no-test': boolean;
-    gen: boolean;
     'no-gen': boolean;
     'no-format': boolean;
     'no-package_json': boolean;
@@ -40,6 +40,7 @@ export declare const Args: z.ZodObject<{
     sync?: boolean | undefined;
     package_json?: boolean | undefined;
     format?: boolean | undefined;
+    gen?: boolean | undefined;
     'no-sync'?: boolean | undefined;
     install?: boolean | undefined;
     'no-install'?: boolean | undefined;
@@ -47,7 +48,6 @@ export declare const Args: z.ZodObject<{
     'no-typecheck'?: boolean | undefined;
     test?: boolean | undefined;
     'no-test'?: boolean | undefined;
-    gen?: boolean | undefined;
     'no-gen'?: boolean | undefined;
     'no-format'?: boolean | undefined;
     'no-package_json'?: boolean | undefined;

package/dist/filer.d.ts

@@ -0,0 +1,29 @@
+import type { Omit_Strict } from '@ryanatkn/belt/types.js';
+import type { Path_Id } from './path.js';
+import { watch_dir, type Watcher_Change, type Options as Watch_Dir_Options } from './watch_dir.js';
+export interface Source_File {
+    id: Path_Id;
+    /**
+     * `null` contents means it doesn't exist.
+     * We create the file in memory to track its dependents regardless of its existence on disk.
+     */
+    contents: string | null;
+    dependents: Map<Path_Id, Source_File>;
+    dependencies: Map<Path_Id, Source_File>;
+}
+export type Cleanup_Watch = () => Promise<void>;
+export type On_Filer_Change = (change: Watcher_Change, source_file: Source_File) => void;
+export interface Options {
+    watch_dir?: typeof watch_dir;
+    watch_dir_options?: Partial<Omit_Strict<Watch_Dir_Options, 'on_change'>>;
+}
+export declare class Filer {
+    #private;
+    files: Map<Path_Id, Source_File>;
+    constructor(options?: Options);
+    get_by_id: (id: Path_Id) => Source_File | undefined;
+    get_or_create: (id: Path_Id) => Source_File;
+    watch(listener: On_Filer_Change): Promise<Cleanup_Watch>;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=filer.d.ts.map

package/dist/filer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filer.d.ts","sourceRoot":"../src/lib/","sources":["filer.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,yBAAyB,CAAC;AAGzD,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,WAAW,CAAC;AACvC,OAAO,EACN,SAAS,EAET,KAAK,cAAc,EACnB,KAAK,OAAO,IAAI,iBAAiB,EAEjC,MAAM,gBAAgB,CAAC;AAUxB,MAAM,WAAW,WAAW;IAC3B,EAAE,EAAE,OAAO,CAAC;IACZ;;;OAGG;IACH,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,UAAU,EAAE,GAAG,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;IACtC,YAAY,EAAE,GAAG,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;CACxC;AAED,MAAM,MAAM,aAAa,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;AAEhD,MAAM,MAAM,eAAe,GAAG,CAAC,MAAM,EAAE,cAAc,EAAE,WAAW,EAAE,WAAW,KAAK,IAAI,CAAC;AAEzF,MAAM,WAAW,OAAO;IACvB,SAAS,CAAC,EAAE,OAAO,SAAS,CAAC;IAC7B,iBAAiB,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,iBAAiB,EAAE,WAAW,CAAC,CAAC,CAAC;CACzE;AAED,qBAAa,KAAK;;IACjB,KAAK,EAAE,GAAG,CAAC,OAAO,EAAE,WAAW,CAAC,CAAa;gBAKjC,OAAO,GAAE,OAAsB;IAU3C,SAAS,OAAQ,OAAO,KAAG,WAAW,GAAG,SAAS,CAEhD;IAEF,aAAa,OAAQ,OAAO,KAAG,WAAW,CAWxC;IA4HI,KAAK,CAAC,QAAQ,EAAE,eAAe,GAAG,OAAO,CAAC,aAAa,CAAC;IAKxD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAQ5B"}

package/dist/filer.js

@@ -0,0 +1,165 @@
+import { EMPTY_OBJECT } from '@ryanatkn/belt/object.js';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { wait } from '@ryanatkn/belt/async.js';
+import { watch_dir, } from './watch_dir.js';
+import { default_file_filter, paths } from './paths.js';
+import { parse_imports } from './parse_imports.js';
+import { resolve_specifier } from './resolve_specifier.js';
+import { default_sveltekit_config } from './sveltekit_config.js';
+import { map_sveltekit_aliases } from './sveltekit_helpers.js';
+import { Unreachable_Error } from '@ryanatkn/belt/error.js';
+const aliases = Object.entries(default_sveltekit_config.alias);
+export class Filer {
+    files = new Map();
+    #watch_dir;
+    #watch_dir_options;
+    constructor(options = EMPTY_OBJECT) {
+        this.#watch_dir = options.watch_dir ?? watch_dir;
+        this.#watch_dir_options = options.watch_dir_options ?? EMPTY_OBJECT;
+    }
+    #watching;
+    #listeners = new Set();
+    #ready = false;
+    get_by_id = (id) => {
+        return this.files.get(id);
+    };
+    get_or_create = (id) => {
+        const existing = this.get_by_id(id);
+        if (existing)
+            return existing;
+        const file = {
+            id,
+            contents: null,
+            dependents: new Map(),
+            dependencies: new Map(),
+        };
+        this.files.set(id, file);
+        return file;
+    };
+    #update(id) {
+        const file = this.get_or_create(id);
+        const new_contents = existsSync(id) ? readFileSync(id, 'utf8') : null;
+        const contents_changed = file.contents !== new_contents;
+        file.contents = new_contents;
+        if (contents_changed) {
+            const dir = dirname(file.id);
+            const dependencies_before = new Set(file.dependencies.keys());
+            const dependencies_removed = new Set(dependencies_before);
+            const imported = file.contents ? parse_imports(file.id, file.contents) : [];
+            for (const specifier of imported) {
+                // TODO logic is duplicated from loader
+                const path = map_sveltekit_aliases(specifier, aliases);
+                // The specifier `path` has now been mapped to its final form, so we can inspect it.
+                if (path[0] === '.' || path[0] === '/') {
+                    const { path_id } = resolve_specifier(path, dir);
+                    dependencies_removed.delete(path_id);
+                    if (!dependencies_before.has(path_id)) {
+                        const d = this.get_or_create(path_id);
+                        file.dependencies.set(d.id, d);
+                        d.dependents.set(file.id, file);
+                    }
+                }
+            }
+            // update any removed dependencies
+            for (const dependency_removed of dependencies_removed) {
+                const deleted1 = file.dependencies.delete(dependency_removed);
+                if (!deleted1)
+                    throw Error('expected to delete1 ' + file.id); // TODO @many delete if correct
+                const dependency_removed_file = this.get_or_create(dependency_removed);
+                const deleted2 = dependency_removed_file.dependents.delete(file.id);
+                if (!deleted2)
+                    throw Error('expected to delete2 ' + file.id); // TODO @many delete if correct
+            }
+        }
+        return file;
+    }
+    #remove(id) {
+        const file = this.get_by_id(id);
+        if (!file)
+            return; // this is safe because the object would exist if any other file referenced it as a dependency or dependent
+        file.contents = null; // clear contents in case it gets re-added later, we want the change to be detected
+        let found = false;
+        for (const d of this.files.values()) {
+            if (d.dependencies.has(file.id)) {
+                found = true;
+                break;
+            }
+        }
+        if (!found)
+            this.files.delete(id);
+        return file;
+    }
+    #notify_listener(listener) {
+        if (!this.#ready)
+            return;
+        for (const source_file of this.files.values()) {
+            listener({ type: 'add', path: source_file.id, is_directory: false }, source_file);
+        }
+    }
+    #notify_change(change, source_file) {
+        if (!this.#ready)
+            return;
+        for (const listener of this.#listeners) {
+            listener(change, source_file);
+        }
+    }
+    async #add_listener(listener) {
+        this.#listeners.add(listener);
+        if (this.#watching) {
+            // if already watching, call the listener for all existing files after init
+            await this.#watching.init();
+            await wait(); // wait a tick to ensure the `this.#ready` value is updated below first
+            this.#notify_listener(listener);
+            return;
+        }
+        this.#watching = this.#watch_dir({
+            filter: (path, is_directory) => (is_directory ? true : default_file_filter(path)),
+            ...this.#watch_dir_options,
+            dir: resolve(this.#watch_dir_options.dir ?? paths.source),
+            on_change: this.#on_change,
+        });
+        await this.#watching.init();
+        this.#ready = true;
+        this.#notify_listener(listener);
+    }
+    async #remove_listener(listener) {
+        this.#listeners.delete(listener);
+        if (this.#listeners.size === 0) {
+            await this.close(); // TODO is this right? should `watch` be async?
+        }
+    }
+    #on_change = (change) => {
+        if (change.is_directory)
+            return;
+        let source_file;
+        switch (change.type) {
+            case 'add':
+            case 'update': {
+                source_file = this.#update(change.path);
+                break;
+            }
+            case 'delete': {
+                source_file = this.#remove(change.path);
+                break;
+            }
+            default:
+                throw new Unreachable_Error(change.type);
+        }
+        if (source_file) {
+            this.#notify_change(change, source_file);
+        }
+    };
+    async watch(listener) {
+        await this.#add_listener(listener);
+        return () => this.#remove_listener(listener);
+    }
+    async close() {
+        this.#ready = false;
+        this.#listeners.clear();
+        if (this.#watching) {
+            await this.#watching.close();
+            this.#watching = undefined;
+        }
+    }
+}

package/dist/gen.task.d.ts

@@ -6,12 +6,12 @@ export declare const Args: z.ZodObject<{
     check: z.ZodDefault<z.ZodBoolean>;
 }, "strict", z.ZodTypeAny, {
     _: string[];
-    check: boolean;
     root_dirs: string[];
+    check: boolean;
 }, {
     _?: string[] | undefined;
-    check?: boolean | undefined;
     root_dirs?: string[] | undefined;
+    check?: boolean | undefined;
 }>;
 export type Args = z.infer<typeof Args>;
 export declare const task: Task<Args>;

package/dist/gro.config.default.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gro.config.default.d.ts","sourceRoot":"../src/lib/","sources":["gro.config.default.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,iBAAiB,CAAC;AAMvD;;;;;;;;GAQG;AACH,QAAA,MAAM,MAAM,EAAE,iBAgBb,CAAC;AAEF,eAAe,MAAM,CAAC"}
+{"version":3,"file":"gro.config.default.d.ts","sourceRoot":"../src/lib/","sources":["gro.config.default.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,iBAAiB,CAAC;AAOvD;;;;;;;;GAQG;AACH,QAAA,MAAM,MAAM,EAAE,iBAcb,CAAC;AAEF,eAAe,MAAM,CAAC"}

package/dist/gro.config.default.js

@@ -2,6 +2,7 @@ import { gro_plugin_sveltekit_library } from './gro_plugin_sveltekit_library.js'
 import { has_server, gro_plugin_server } from './gro_plugin_server.js';
 import { gro_plugin_sveltekit_app } from './gro_plugin_sveltekit_app.js';
 import { has_sveltekit_app, has_sveltekit_library } from './sveltekit_helpers.js';
+import { gro_plugin_gen } from './gro_plugin_gen.js';
 /**
  * This is the default config that's passed to `gro.config.ts`
  * if it exists in the current project, and if not, this is the final config.
@@ -19,9 +20,7 @@ const config = async (cfg) => {
         has_sveltekit_app_result.ok
             ? gro_plugin_sveltekit_app({ host_target: has_server_result.ok ? 'node' : 'github_pages' })
             : null,
-        // TODO replace with an esbuild plugin, see the module for more
-        // import {gro_plugin_gen} from './gro_plugin_gen.js';
-        // gro_plugin_gen(),
+        gro_plugin_gen(),
     ];
     return cfg;
 };

package/dist/gro_plugin_gen.d.ts

@@ -1,7 +1,14 @@
-import type { Plugin, Plugin_Context } from './plugin.js';
+import type { Plugin } from './plugin.js';
 import type { Args } from './args.js';
+import type { File_Filter, Path_Id } from './path.js';
+import type { Source_File } from './filer.js';
 export interface Task_Args extends Args {
     watch?: boolean;
 }
-export declare const plugin: () => Plugin<Plugin_Context<Task_Args>>;
+export interface Options {
+    root_dirs?: string[];
+    flush_debounce_delay?: number;
+}
+export declare const gro_plugin_gen: ({ root_dirs, flush_debounce_delay, }?: Options) => Plugin;
+export declare const filter_dependents: (source_file: Source_File, get_by_id: (id: Path_Id) => Source_File | undefined, filter?: File_Filter, results?: Set<string>, searched?: Set<string>) => Set<string>;
 //# sourceMappingURL=gro_plugin_gen.d.ts.map

package/dist/gro_plugin_gen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gro_plugin_gen.d.ts","sourceRoot":"../src/lib/","sources":["gro_plugin_gen.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,MAAM,EAAE,cAAc,EAAC,MAAM,aAAa,CAAC;AACxD,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,WAAW,CAAC;AAQpC,MAAM,WAAW,SAAU,SAAQ,IAAI;IACtC,KAAK,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,eAAO,MAAM,MAAM,QAAO,MAAM,CAAC,cAAc,CAAC,SAAS,CAAC,CA6EzD,CAAC"}
+{"version":3,"file":"gro_plugin_gen.d.ts","sourceRoot":"../src/lib/","sources":["gro_plugin_gen.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,WAAW,CAAC;AAKpC,OAAO,KAAK,EAAC,WAAW,EAAE,OAAO,EAAC,MAAM,WAAW,CAAC;AACpD,OAAO,KAAK,EAAgB,WAAW,EAAC,MAAM,YAAY,CAAC;AAK3D,MAAM,WAAW,SAAU,SAAQ,IAAI;IACtC,KAAK,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,OAAO;IACvB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,eAAO,MAAM,cAAc,0CAGxB,OAAO,KAAkB,MA+F3B,CAAC;AAEF,eAAO,MAAM,iBAAiB,gBAChB,WAAW,aACb,CAAC,EAAE,EAAE,OAAO,KAAK,WAAW,GAAG,SAAS,WAC1C,WAAW,YACX,GAAG,CAAC,MAAM,CAAC,aACV,GAAG,CAAC,MAAM,CAAC,KACnB,GAAG,CAAC,MAAM,CAYZ,CAAC"}

package/dist/gro_plugin_gen.js

@@ -1,19 +1,24 @@
-// TODO this became unused with https://github.com/ryanatkn/gro/pull/382
-// because we no longer have a normal system build - replace with an esbuild plugin
-// @ts-nocheck
-import { path_id_to_base_path } from './paths.js';
+import { EMPTY_OBJECT } from '@ryanatkn/belt/object.js';
+import { paths } from './paths.js';
 import { find_genfiles, is_gen_path } from './gen.js';
-import { filter_dependents } from './build/source_file.js';
 import { throttle } from './throttle.js';
+import { spawn_cli } from './cli.js';
+import { Unreachable_Error } from '@ryanatkn/belt/error.js';
 const FLUSH_DEBOUNCE_DELAY = 500;
-export const plugin = () => {
+export const gro_plugin_gen = ({ root_dirs = [paths.source], flush_debounce_delay = FLUSH_DEBOUNCE_DELAY, } = EMPTY_OBJECT) => {
+    const input_path = paths.source; // TODO option?
     let generating = false;
     let regen = false;
-    let on_filer_build;
+    let flushing_timeout;
     const queued_files = new Set();
-    const queue_gen = (gen_file_name) => {
-        queued_files.add(gen_file_name);
-        void flush_gen_queue();
+    const queue_gen = (gen_file_id) => {
+        queued_files.add(gen_file_id);
+        if (flushing_timeout === undefined) {
+            flushing_timeout = setTimeout(() => {
+                flushing_timeout = undefined;
+                void flush_gen_queue();
+            }); // the timeout batches synchronously
+        }
     };
     const flush_gen_queue = throttle(async () => {
         // hacky way to avoid concurrent `gro gen` calls
@@ -30,50 +35,75 @@ export const plugin = () => {
             regen = false;
             void flush_gen_queue();
         }
-    }, FLUSH_DEBOUNCE_DELAY);
+    }, flush_debounce_delay);
     const gen = (files = []) => spawn_cli('gro', ['gen', ...files]);
+    let cleanup;
     return {
         name: 'gro_plugin_gen',
-        setup: async ({ args: { watch }, dev, log, config }) => {
+        setup: async ({ watch, dev, log, config, filer }) => {
             // For production builds, we assume `gen` is already fresh,
             // which should be checked by CI via `gro check` which calls `gro gen --check`.
             if (!dev)
                 return;
-            // Run `gen`, first checking if there are any modules to avoid a console error.
-            // Some parts of the build may have already happened,
-            // making us miss `build` events for gen dependencies,
-            // so we run `gen` here even if it's usually wasteful.
-            const found = find_genfiles([paths.source], root_dirs, config);
-            if (found.ok && found.value.resolved_input_files.size > 0) {
-                await gen();
-            }
             // Do we need to just generate everything once and exit?
             // TODO could we have an esbuild context here? problem is watching the right files, maybe a plugin that tracks deps
-            if (!filer || !watch) {
+            if (!watch) {
                 log.info('generating and exiting early');
+                // Run `gen`, first checking if there are any modules to avoid a console error.
+                // Some parts of the build may have already happened,
+                // making us miss `build` events for gen dependencies,
+                // so we run `gen` here even if it's usually wasteful.
+                const found = find_genfiles([input_path], root_dirs, config);
+                if (found.ok && found.value.resolved_input_files.length > 0) {
+                    await gen();
+                }
                 return;
             }
             // When a file builds, check it and its tree of dependents
             // for any `.gen.` files that need to run.
-            on_filer_build = ({ source_file, build_config }) => {
-                // TODO how to handle this now? the loader traces deps for us with `parentPath`,
-                // but we probably want to make this an esbuild plugin instead
-                // if (build_config.name !== 'system') return;
-                if (is_gen_path(source_file.id)) {
-                    queue_gen(path_id_to_base_path(source_file.id));
+            cleanup = await filer.watch((change, source_file) => {
+                switch (change.type) {
+                    case 'add':
+                    case 'update': {
+                        // TODO how to handle this now? the loader traces deps for us with `parentPath`,
+                        // but we probably want to make this an esbuild plugin instead
+                        if (is_gen_path(source_file.id)) {
+                            queue_gen(source_file.id);
+                        }
+                        const dependent_gen_file_ids = filter_dependents(source_file, filer.get_by_id, is_gen_path);
+                        for (const dependent_gen_file_id of dependent_gen_file_ids) {
+                            queue_gen(dependent_gen_file_id);
+                        }
+                        break;
+                    }
+                    case 'delete': {
+                        // TODO delete the generated file(s)? option?
+                        break;
+                    }
+                    default:
+                        throw new Unreachable_Error(change.type);
                 }
-                const dependent_gen_file_ids = filter_dependents(source_file, build_config, filer.find_by_id, // cast because we can assume they're all `SourceFile`s
-                is_gen_path);
-                for (const dependent_gen_file_id of dependent_gen_file_ids) {
-                    queue_gen(path_id_to_base_path(dependent_gen_file_id));
-                }
-            };
-            filer.on('build', on_filer_build);
+            });
         },
-        teardown: ({ filer }) => {
-            if (on_filer_build && filer) {
-                filer.off('build', on_filer_build);
+        teardown: async () => {
+            if (cleanup !== undefined) {
+                await cleanup();
+                cleanup = undefined;
             }
         },
     };
 };
+export const filter_dependents = (source_file, get_by_id, filter, results = new Set(), searched = new Set()) => {
+    const { dependents } = source_file;
+    for (const dependent_id of dependents.keys()) {
+        if (searched.has(dependent_id))
+            continue;
+        searched.add(dependent_id);
+        if (!filter || filter(dependent_id)) {
+            results.add(dependent_id);
+        }
+        const dependent_source_File = get_by_id(dependent_id);
+        filter_dependents(dependent_source_File, get_by_id, filter, results, searched);
+    }
+    return results;
+};

package/dist/gro_plugin_sveltekit_library.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gro_plugin_sveltekit_library.d.ts","sourceRoot":"../src/lib/","sources":["gro_plugin_sveltekit_library.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAKxC,OAAO,EAGN,KAAK,sBAAsB,EAC3B,MAAM,wBAAwB,CAAC;AAEhC,MAAM,WAAW,OAAO;IACvB;;;OAGG;IACH,sBAAsB,CAAC,EAAE,sBAAsB,CAAC;IAChD;;;OAGG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,eAAO,MAAM,4BAA4B,qDAGtC,OAAO,KAAQ,MA4CjB,CAAC"}
+{"version":3,"file":"gro_plugin_sveltekit_library.d.ts","sourceRoot":"../src/lib/","sources":["gro_plugin_sveltekit_library.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAGxC,OAAO,EAGN,KAAK,sBAAsB,EAC3B,MAAM,wBAAwB,CAAC;AAEhC,MAAM,WAAW,OAAO;IACvB;;;OAGG;IACH,sBAAsB,CAAC,EAAE,sBAAsB,CAAC;IAChD;;;OAGG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,eAAO,MAAM,4BAA4B,qDAGtC,OAAO,KAAQ,MA8BjB,CAAC"}

package/dist/gro_plugin_sveltekit_library.js

@@ -1,26 +1,14 @@
 import { print_spawn_result, spawn } from '@ryanatkn/belt/process.js';
 import { Task_Error } from './task.js';
 import { load_package_json } from './package_json.js';
-import { serialize_args, to_forwarded_args } from './args.js';
-import { find_cli, spawn_cli } from './cli.js';
-import { SVELTE_PACKAGE_CLI, has_sveltekit_library, } from './sveltekit_helpers.js';
+import { SVELTE_PACKAGE_CLI, run_svelte_package, } from './sveltekit_helpers.js';
 export const gro_plugin_sveltekit_library = ({ svelte_package_options, svelte_package_cli = SVELTE_PACKAGE_CLI, } = {}) => {
     return {
         name: 'gro_plugin_sveltekit_library',
-        setup: async ({ log }) => {
-            const has_sveltekit_library_result = has_sveltekit_library();
-            if (!has_sveltekit_library_result.ok) {
-                throw new Task_Error('Failed to find SvelteKit library: ' + has_sveltekit_library_result.message);
+        setup: async ({ dev, log }) => {
+            if (!dev) {
+                await run_svelte_package(svelte_package_options, svelte_package_cli, log);
             }
-            const found_svelte_package_cli = find_cli(svelte_package_cli);
-            if (found_svelte_package_cli?.kind !== 'local') {
-                throw new Task_Error(`Failed to find SvelteKit packaging CLI \`${svelte_package_cli}\`, do you need to run \`npm i\`?`);
-            }
-            const serialized_args = serialize_args({
-                ...svelte_package_options,
-                ...to_forwarded_args(svelte_package_cli),
-            });
-            await spawn_cli(found_svelte_package_cli, serialized_args, log);
         },
         adapt: async ({ log, timings }) => {
             const package_json = load_package_json();

package/dist/invoke_task.d.ts

@@ -2,6 +2,7 @@ import { Timings } from '@ryanatkn/belt/timings.js';
 import { type Args } from './args.js';
 import { Raw_Input_Path } from './input_path.js';
 import type { Gro_Config } from './gro_config.js';
+import { Filer } from './filer.js';
 /**
  * Invokes Gro tasks by name using the filesystem as the source.
  *
@@ -24,5 +25,5 @@ import type { Gro_Config } from './gro_config.js';
  * @param config - The Gro configuration.
  * @param initial_timings - The timings to use for the top-level task, `null` for composed tasks.
  */
-export declare const invoke_task: (task_name: Raw_Input_Path, args: Args | undefined, config: Gro_Config, initial_timings?: Timings | null) => Promise<void>;
+export declare const invoke_task: (task_name: Raw_Input_Path, args: Args | undefined, config: Gro_Config, initial_filer?: Filer, initial_timings?: Timings | null) => Promise<void>;
 //# sourceMappingURL=invoke_task.d.ts.map

package/dist/invoke_task.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"invoke_task.d.ts","sourceRoot":"../src/lib/","sources":["invoke_task.ts"],"names":[],"mappings":"AAEA,OAAO,EAAmB,OAAO,EAAC,MAAM,2BAA2B,CAAC;AAGpE,OAAO,EAAoB,KAAK,IAAI,EAAC,MAAM,WAAW,CAAC;AAEvD,OAAO,EAAgB,cAAc,EAAC,MAAM,iBAAiB,CAAC;AAI9D,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,iBAAiB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,WAAW,cACZ,cAAc,QACnB,IAAI,GAAG,SAAS,UACd,UAAU,oBACD,OAAO,GAAG,IAAI,KAC7B,OAAO,CAAC,IAAI,CA6Ed,CAAC"}
+{"version":3,"file":"invoke_task.d.ts","sourceRoot":"../src/lib/","sources":["invoke_task.ts"],"names":[],"mappings":"AAEA,OAAO,EAAmB,OAAO,EAAC,MAAM,2BAA2B,CAAC;AAGpE,OAAO,EAAoB,KAAK,IAAI,EAAC,MAAM,WAAW,CAAC;AAEvD,OAAO,EAAgB,cAAc,EAAC,MAAM,iBAAiB,CAAC;AAI9D,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAC,KAAK,EAAC,MAAM,YAAY,CAAC;AAEjC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,WAAW,cACZ,cAAc,QACnB,IAAI,GAAG,SAAS,UACd,UAAU,kBACF,KAAK,oBACH,OAAO,GAAG,IAAI,KAC9B,OAAO,CAAC,IAAI,CAgFd,CAAC"}

package/dist/invoke_task.js

@@ -8,6 +8,7 @@ import { to_input_path, Raw_Input_Path } from './input_path.js';
 import { find_tasks, load_tasks, Silent_Error } from './task.js';
 import { load_gro_package_json } from './package_json.js';
 import { log_tasks, log_error_reasons } from './task_logging.js';
+import { Filer } from './filer.js';
 /**
  * Invokes Gro tasks by name using the filesystem as the source.
  *
@@ -30,9 +31,10 @@ import { log_tasks, log_error_reasons } from './task_logging.js';
  * @param config - The Gro configuration.
  * @param initial_timings - The timings to use for the top-level task, `null` for composed tasks.
  */
-export const invoke_task = async (task_name, args, config, initial_timings = null) => {
+export const invoke_task = async (task_name, args, config, initial_filer, initial_timings) => {
     const log = new System_Logger(print_log_label(task_name || 'gro'));
     log.info('invoking', task_name ? st('cyan', task_name) : 'gro');
+    const filer = initial_filer ?? new Filer();
     const timings = initial_timings ?? new Timings();
     const total_timing = create_stopwatch();
     const finish = () => {
@@ -80,7 +82,7 @@ export const invoke_task = async (task_name, args, config, initial_timings = nul
     const task = loaded_tasks.modules[0];
     log.info(`→ ${st('cyan', task.name)} ${(task.mod.task.summary && st('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);
+    const result = await run_task(task, { ...args, ...to_forwarded_args(`gro ${task.name}`) }, invoke_task, config, filer, timings);
     timing_to_run_task();
     if (!result.ok) {
         log.info(`${st('red', '🞩')} ${st('cyan', task.name)}`);

package/dist/loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loader.d.ts","sourceRoot":"../src/lib/","sources":["loader.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,QAAQ,EAAE,WAAW,EAAC,MAAM,aAAa,CAAC;AA+EvD,eAAO,MAAM,IAAI,EAAE,QAwFlB,CAAC;AAEF,eAAO,MAAM,OAAO,EAAE,WA4DrB,CAAC"}
+{"version":3,"file":"loader.d.ts","sourceRoot":"../src/lib/","sources":["loader.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,QAAQ,EAAE,WAAW,EAAC,MAAM,aAAa,CAAC;AAgFvD,eAAO,MAAM,IAAI,EAAE,QAwFlB,CAAC;AAEF,eAAO,MAAM,OAAO,EAAE,WAoDrB,CAAC"}

package/dist/loader.js

@@ -13,6 +13,7 @@ import { JSON_MATCHER, NODE_MODULES_DIRNAME, TS_MATCHER } from './path_constants
 import { to_define_import_meta_env, default_ts_transform_options } from './esbuild_helpers.js';
 import { resolve_specifier } from './resolve_specifier.js';
 import { resolve_node_specifier } from './resolve_node_specifier.js';
+import { map_sveltekit_aliases } from './sveltekit_helpers.js';
 /*
 
 Usage via `$lib/register.ts`:
@@ -47,7 +48,7 @@ const ts_transform_options = {
     define: to_define_import_meta_env(dev, base_url),
     sourcemap: 'inline',
 };
-const aliases = Object.entries({ $lib: 'src/lib', ...alias });
+const aliases = Object.entries(alias);
 const RAW_MATCHER = /(%3Fraw|\.css|\.svg)$/; // TODO others? configurable?
 const ENV_MATCHER = /src\/lib\/\$env\/(static|dynamic)\/(public|private)$/;
 const NODE_MODULES_MATCHER = new RegExp(escape_regexp('/' + NODE_MODULES_DIRNAME + '/'), 'u');
@@ -151,14 +152,7 @@ export const resolve = async (specifier, context, nextResolve) => {
     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;
-        }
-    }
+    const path = map_sveltekit_aliases(specifier, aliases);
     // 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`.

package/dist/package.d.ts

@@ -177,6 +177,10 @@ export declare const package_json: {
             types: string;
             default: string;
         };
+        './filer.js': {
+            types: string;
+            default: string;
+        };
         './format_directory.js': {
             types: string;
             default: string;
@@ -289,6 +293,10 @@ export declare const package_json: {
             types: string;
             default: string;
         };
+        './parse_imports.js': {
+            types: string;
+            default: string;
+        };
         './path_constants.js': {
             types: string;
             default: string;
@@ -582,6 +590,13 @@ export declare const src_json: {
                 kind: string;
             }[];
         };
+        './filer.js': {
+            path: string;
+            declarations: {
+                name: string;
+                kind: string;
+            }[];
+        };
         './format_directory.js': {
             path: string;
             declarations: {
@@ -772,6 +787,13 @@ export declare const src_json: {
                 kind: string;
             }[];
         };
+        './parse_imports.js': {
+            path: string;
+            declarations: {
+                name: string;
+                kind: string;
+            }[];
+        };
         './path_constants.js': {
             path: string;
             declarations: {

package/dist/package.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"package.d.ts","sourceRoot":"../src/lib/","sources":["package.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqQD,CAAC;AAEzB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsuBD,CAAC"}
+{"version":3,"file":"package.d.ts","sourceRoot":"../src/lib/","sources":["package.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuQD,CAAC;AAEzB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8vBD,CAAC"}