@ryanatkn/gro 0.112.0

package/dist/gro_plugin_server.js

@@ -0,0 +1,152 @@
+import { spawn_restartable_process } from '@ryanatkn/belt/process.js';
+import * as esbuild from 'esbuild';
+import { cwd } from 'node:process';
+import { join, resolve } from 'node:path';
+import { identity } from '@ryanatkn/belt/function.js';
+import { strip_before } from '@ryanatkn/belt/string.js';
+import { base_path_to_source_id, GRO_DEV_DIRNAME, SERVER_DIST_PATH, LIB_DIRNAME, paths, } from './paths.js';
+import { watch_dir } from './watch_dir.js';
+import { init_sveltekit_config } from './sveltekit_config.js';
+import { esbuild_plugin_sveltekit_shim_app } from './esbuild_plugin_sveltekit_shim_app.js';
+import { esbuild_plugin_sveltekit_shim_env } from './esbuild_plugin_sveltekit_shim_env.js';
+import { print_build_result, to_define_import_meta_env } from './esbuild_helpers.js';
+import { esbuild_plugin_sveltekit_shim_alias } from './esbuild_plugin_sveltekit_shim_alias.js';
+import { esbuild_plugin_external_worker } from './esbuild_plugin_external_worker.js';
+import { esbuild_plugin_sveltekit_local_imports } from './esbuild_plugin_sveltekit_local_imports.js';
+import { exists } from './fs.js';
+import { esbuild_plugin_svelte } from './esbuild_plugin_svelte.js';
+import { throttle } from './throttle.js';
+// TODO sourcemap as a hoisted option? disable for production by default - or like `outpaths`, passed a `dev` param
+export const SERVER_SOURCE_ID = base_path_to_source_id(LIB_DIRNAME + '/server/server.ts');
+export const has_server = (path = SERVER_SOURCE_ID) => exists(path);
+export const gro_plugin_server = ({ entry_points = [SERVER_SOURCE_ID], dir = cwd(), outpaths = (dev) => ({
+    outdir: join(dir, dev ? GRO_DEV_DIRNAME : SERVER_DIST_PATH),
+    outbase: paths.lib,
+    outname: 'server/server.js',
+}), env_files, ambient_env, sveltekit_config, target = 'esnext', esbuild_build_options = identity, rebuild_throttle_delay = 1000, cli_command = 'node', run, // `dev` default is not available in this scope
+ } = {}) => {
+    let build_ctx;
+    let watcher;
+    let server_process = null;
+    let deps = null;
+    return {
+        name: 'gro_plugin_server',
+        setup: async ({ dev, watch, timings, log }) => {
+            const { alias, base_url, assets_url, env_dir, private_prefix, public_prefix, svelte_compile_options, svelte_preprocessors, } = await init_sveltekit_config(sveltekit_config ?? dir);
+            const { outbase, outdir, outname } = outpaths(dev);
+            const server_outpath = join(outdir, outname);
+            const timing_to_esbuild_create_context = timings.start('create build context');
+            const build_options = esbuild_build_options({
+                outdir,
+                outbase,
+                format: 'esm',
+                platform: 'node',
+                packages: 'external',
+                bundle: true,
+                target,
+                metafile: watch,
+            });
+            build_ctx = await esbuild.context({
+                entryPoints: entry_points.map((path) => resolve(dir, path)),
+                plugins: [
+                    esbuild_plugin_sveltekit_shim_app({ dev, base_url, assets_url }),
+                    esbuild_plugin_sveltekit_shim_env({
+                        dev,
+                        public_prefix,
+                        private_prefix,
+                        env_dir,
+                        env_files,
+                        ambient_env,
+                    }),
+                    esbuild_plugin_sveltekit_shim_alias({ dir, alias }),
+                    esbuild_plugin_external_worker({
+                        dev,
+                        build_options,
+                        dir,
+                        svelte_compile_options,
+                        svelte_preprocessors,
+                        alias,
+                        base_url,
+                        public_prefix,
+                        private_prefix,
+                        env_dir,
+                        env_files,
+                        ambient_env,
+                        log,
+                    }),
+                    esbuild_plugin_svelte({ dir, svelte_compile_options, svelte_preprocessors }),
+                    esbuild_plugin_sveltekit_local_imports(),
+                ],
+                define: to_define_import_meta_env(dev, base_url),
+                ...build_options,
+            });
+            timing_to_esbuild_create_context();
+            const rebuild = throttle(async () => {
+                let build_result;
+                try {
+                    build_result = await build_ctx.rebuild();
+                }
+                catch (err) {
+                    log.error('[gro_plugin_server] build failed', err);
+                    return;
+                }
+                const { metafile } = build_result;
+                if (!metafile)
+                    return;
+                print_build_result(log, build_result);
+                deps = parse_deps(metafile.inputs, dir);
+                server_process?.restart();
+            }, rebuild_throttle_delay);
+            await rebuild();
+            // uses chokidar instead of esbuild's watcher for efficiency
+            if (watch) {
+                let watcher_ready = false;
+                // TODO maybe reuse this watcher globally via an option,
+                // because it watches all of `$lib`, and that means it excludes `$routes`
+                // while also including a lot of client files we don't care about,
+                // but we can't discern which of `$lib` to watch ahead of time
+                watcher = watch_dir({
+                    dir: paths.lib,
+                    on_change: (change) => {
+                        if (!watcher_ready || !deps?.has(change.path))
+                            return;
+                        void rebuild();
+                    },
+                });
+                await watcher.init();
+                watcher_ready = true;
+            }
+            if (!(await exists(server_outpath))) {
+                throw Error(`Node server failed to start due to missing file: ${server_outpath}`);
+            }
+            if (run ?? dev) {
+                server_process = spawn_restartable_process(cli_command, [server_outpath]);
+            }
+        },
+        teardown: async () => {
+            if (server_process) {
+                const s = server_process; // avoid possible issue where a build is in progress, don't want to issue a restart, could be fixed upstream in `spawn_restartable_process`
+                server_process = null;
+                await s.kill();
+            }
+            if (watcher) {
+                await watcher.close();
+            }
+            if (build_ctx) {
+                await build_ctx.dispose();
+            }
+        },
+    };
+};
+/**
+ * The esbuild metafile contains the paths in `entryPoints` relative to the `dir`
+ * even though we're resolving them to absolute paths before passing them to esbuild,
+ * so we resolve them here relative to the `dir`.
+ */
+const parse_deps = (metafile_inputs, dir) => {
+    const deps = new Set();
+    for (const key in metafile_inputs) {
+        deps.add(resolve(dir, strip_before(key, ':')));
+    }
+    return deps;
+};

package/dist/gro_plugin_sveltekit_app.d.ts

@@ -0,0 +1,27 @@
+import type { Plugin, Plugin_Context } from './plugin.js';
+import { type Map_Package_Json } from './package_json.js';
+import { type Map_Src_Json } from './src_json.js';
+export declare const has_sveltekit_app: () => Promise<boolean>;
+export interface Options {
+    /**
+     * Used for finalizing a SvelteKit build like adding a `.nojekyll` file for GitHub Pages.
+     * @default 'github_pages'
+     */
+    host_target?: Host_Target;
+    /**
+     * If truthy, adds `/.well-known/package.json` to the static output.
+     * If a function, maps the value.
+     */
+    well_known_package_json?: boolean | Map_Package_Json;
+    /**
+     * If truthy, adds `/.well-known/src.json` and `/.well-known/src/` to the static output.
+     * If a function, maps the value.
+     */
+    well_known_src_json?: boolean | Map_Src_Json;
+    /**
+     * Filter what's copied from `src/` to `.well-known/src/`.
+     */
+    filter_well_known_src?: (source: string, destination: string) => boolean | Promise<boolean>;
+}
+export type Host_Target = 'github_pages' | 'static' | 'node';
+export declare const gro_plugin_sveltekit_app: ({ host_target, well_known_package_json, well_known_src_json, filter_well_known_src, }?: Options) => Plugin<Plugin_Context>;

package/dist/gro_plugin_sveltekit_app.js

@@ -0,0 +1,180 @@
+import { spawn_process } from '@ryanatkn/belt/process.js';
+import { cp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { print_command_args, serialize_args, to_forwarded_args } from './args.js';
+import { exists } from './fs.js';
+import { serialize_package_json, load_package_json } from './package_json.js';
+import { init_sveltekit_config } from './sveltekit_config.js';
+import { Task_Error } from './task.js';
+import { spawn_cli } from './cli.js';
+import { serialize_src_json, create_src_json } from './src_json.js';
+import { DEFAULT_EXPORTS_EXCLUDER } from './config.js';
+import { SVELTEKIT_CONFIG_FILENAME } from './paths.js';
+export const has_sveltekit_app = () => exists(SVELTEKIT_CONFIG_FILENAME);
+export const gro_plugin_sveltekit_app = ({ host_target = 'github_pages', well_known_package_json, well_known_src_json, filter_well_known_src = (source) => !DEFAULT_EXPORTS_EXCLUDER.test(source), } = {}) => {
+    let sveltekit_process = null;
+    return {
+        name: 'gro_plugin_sveltekit_app',
+        setup: async ({ dev, watch, log }) => {
+            if (dev) {
+                // `vite dev` in development mode
+                if (watch) {
+                    const serialized_args = ['vite', 'dev', ...serialize_args(to_forwarded_args('vite'))];
+                    log.info(print_command_args(serialized_args));
+                    sveltekit_process = spawn_process('npx', serialized_args);
+                }
+                else {
+                    log.debug(`the SvelteKit frontend plugin is loaded but will not output anything` +
+                        ' because `dev` is true and `watch` is false');
+                }
+            }
+            else {
+                // `vite build` in production mode
+                // `.well-known/package.json`
+                const package_json = await load_package_json(); // TODO put in plugin context? same with sveltekit config?
+                if (well_known_package_json === undefined) {
+                    well_known_package_json = package_json.public; // eslint-disable-line no-param-reassign
+                }
+                const mapped_package_json = !well_known_package_json
+                    ? null
+                    : well_known_package_json === true
+                        ? package_json
+                        : await well_known_package_json(package_json);
+                const serialized_package_json = mapped_package_json && serialize_package_json(mapped_package_json);
+                // `.well-known/src.json` and `.well-known/src/`
+                const final_package_json = mapped_package_json || package_json;
+                const src_json = await create_src_json(final_package_json);
+                if (well_known_src_json === undefined) {
+                    well_known_src_json = final_package_json.public; // eslint-disable-line no-param-reassign
+                }
+                const mapped_src_json = !well_known_src_json
+                    ? null
+                    : well_known_src_json === true
+                        ? src_json
+                        : await well_known_src_json(src_json);
+                const serialized_src_json = mapped_src_json && serialize_src_json(mapped_src_json);
+                // TODO this strategy means the files aren't available during development --
+                // maybe a Vite middleware is best? what if this plugin added its plugin to your `vite.config.ts`?
+                // copy files to `static` before building, in such a way
+                // that's non-destructive to existing files and dirs and easy to clean up
+                const { assets_path } = await init_sveltekit_config(); // TODO probably put in plugin context
+                const cleanups = [
+                    serialized_package_json
+                        ? await create_temporarily(join(assets_path, '.well-known/package.json'), serialized_package_json)
+                        : null,
+                    serialized_src_json
+                        ? await create_temporarily(join(assets_path, '.well-known/src.json'), serialized_src_json)
+                        : null,
+                    serialized_src_json
+                        ? await copy_temporarily('src', assets_path, '.well-known', filter_well_known_src)
+                        : null,
+                    /**
+                     * GitHub pages processes everything with Jekyll by default,
+                     * breaking things like files and dirs prefixed with an underscore.
+                     * This adds a `.nojekyll` file to the root of the output
+                     * to tell GitHub Pages to treat the outputs as plain static files.
+                     */
+                    host_target === 'github_pages'
+                        ? await create_temporarily(join(assets_path, '.nojekyll'), '')
+                        : null,
+                ].filter(Boolean);
+                const cleanup = () => Promise.all(cleanups.map((c) => c()));
+                try {
+                    const serialized_args = ['build', ...serialize_args(to_forwarded_args('vite'))];
+                    log.info(print_command_args(['vite'].concat(serialized_args)));
+                    const spawned = await spawn_cli('vite', serialized_args); // TODO call with the gro helper instead of npx?
+                    if (!spawned?.ok) {
+                        throw new Task_Error('vite build failed with exit code ' + spawned?.code);
+                    }
+                }
+                catch (err) {
+                    await cleanup();
+                    throw err;
+                }
+                await cleanup();
+            }
+        },
+        teardown: async () => {
+            if (sveltekit_process) {
+                sveltekit_process.child.kill();
+                await sveltekit_process.closed;
+            }
+        },
+    };
+};
+// TODO probably extract these, and create a common helper or merge them
+const copy_temporarily = async (source_path, dest_dir, dest_base_dir = '', filter) => {
+    const path = join(dest_dir, dest_base_dir, source_path);
+    const dir = dirname(path);
+    const dir_already_exists = await exists(dir);
+    let root_created_dir;
+    if (!dir_already_exists) {
+        root_created_dir = await to_root_dir_that_doesnt_exist(dir);
+        if (!root_created_dir)
+            throw Error();
+        await mkdir(dir, { recursive: true });
+    }
+    const path_already_exists = await exists(path);
+    if (!path_already_exists) {
+        await cp(source_path, path, { recursive: true, filter });
+    }
+    return async () => {
+        if (!dir_already_exists) {
+            if (!root_created_dir)
+                throw Error();
+            await rm(root_created_dir, { recursive: true });
+        }
+        else if (!path_already_exists) {
+            await rm(path, { recursive: true });
+        }
+    };
+};
+/**
+ * Creates a file at `path` with `contents` if it doesn't already exist,
+ * and returns a function that deletes the file and any created directories.
+ * @param path
+ * @param contents
+ * @returns cleanup function that deletes the file and any created dirs
+ */
+const create_temporarily = async (path, contents) => {
+    const dir = dirname(path);
+    const dir_already_exists = await exists(dir);
+    let root_created_dir;
+    if (!dir_already_exists) {
+        root_created_dir = await to_root_dir_that_doesnt_exist(dir);
+        if (!root_created_dir)
+            throw Error();
+        await mkdir(dir, { recursive: true });
+    }
+    const path_already_exists = await exists(path);
+    if (!path_already_exists) {
+        await writeFile(path, contents, 'utf8');
+    }
+    return async () => {
+        if (!dir_already_exists) {
+            if (!root_created_dir)
+                throw Error();
+            await rm(root_created_dir, { recursive: true });
+        }
+        else if (!path_already_exists) {
+            await rm(path);
+        }
+    };
+};
+/**
+ * Niche and probably needs refactoring,
+ * for `/a/b/DOESNT_EXIST/NOR_THIS/ETC` returns `/a/b/DOESNT_EXIST`
+ * where `/a/b` does exist on the filesystem and `DOESNT_EXIST` is not one of its subdirectories.
+ */
+const to_root_dir_that_doesnt_exist = async (dir) => {
+    let prev;
+    let d = dir;
+    do {
+        // eslint-disable-next-line no-await-in-loop
+        if (await exists(d)) {
+            return prev;
+        }
+        prev = d;
+    } while ((d = dirname(d)));
+    throw Error('no dirs exist for ' + dir);
+};

package/dist/gro_plugin_sveltekit_library.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin, Plugin_Context } from './plugin.js';
+import { Package_Json } from './package_json.js';
+export declare const has_sveltekit_library: (package_json?: Package_Json) => Promise<boolean>;
+export declare const gro_plugin_sveltekit_library: () => Plugin<Plugin_Context>;

package/dist/gro_plugin_sveltekit_library.js

@@ -0,0 +1,42 @@
+import { print_spawn_result, spawn } from '@ryanatkn/belt/process.js';
+import { Task_Error } from './task.js';
+import { Package_Json, load_package_json } from './package_json.js';
+import { print_command_args, serialize_args, to_forwarded_args } from './args.js';
+import { find_cli, spawn_cli } from './cli.js';
+export const has_sveltekit_library = async (package_json) => {
+    const p = package_json ?? (await load_package_json()); // TODO from param, on config?
+    return !!p.devDependencies?.['@sveltejs/package'] || !!p.dependencies?.['@sveltejs/package'];
+    // TODO @multiple get from the sveltekit config
+    // && exists(sveltekit_config.lib_path);
+};
+export const gro_plugin_sveltekit_library = () => {
+    return {
+        name: 'gro_plugin_sveltekit_library',
+        setup: async ({ log }) => {
+            if ((await find_cli('svelte-package')) !== 'local') {
+                throw new Task_Error('Failed to find svelte-package, run `npm i -D @sveltejs/package`');
+            }
+            const serialized_args = serialize_args(to_forwarded_args('svelte-package'));
+            log.info(print_command_args(serialized_args));
+            await spawn_cli('svelte-package', serialized_args);
+        },
+        adapt: async ({ log, timings }) => {
+            const package_json = await load_package_json();
+            // `npm link`
+            if (package_json.bin) {
+                const timing_to_npm_link = timings.start('npm link');
+                await Promise.all(Object.values(package_json.bin).map(async (bin_path) => {
+                    const chmod_result = await spawn('chmod', ['+x', bin_path]);
+                    if (!chmod_result.ok)
+                        log.error(`chmod on bin path ${bin_path} failed with code ${chmod_result.code}`);
+                }));
+                log.info(`linking`);
+                const link_result = await spawn('npm', ['link', '-f']); // TODO don't use `-f` unless necessary or at all?
+                if (!link_result.ok) {
+                    throw new Task_Error(`Failed to link. ${print_spawn_result(link_result)}`);
+                }
+                timing_to_npm_link();
+            }
+        },
+    };
+};

package/dist/hash.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+/**
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto
+ */
+export declare const to_hash: (data: Buffer, algorithm?: 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512') => Promise<string>;

package/dist/hash.js

@@ -0,0 +1,14 @@
+import { webcrypto } from 'node:crypto';
+const { subtle } = webcrypto;
+/**
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto
+ */
+export const to_hash = async (data, algorithm = 'SHA-256') => {
+    const digested = await subtle.digest(algorithm, data);
+    const bytes = Array.from(new Uint8Array(digested));
+    let hex = '';
+    for (const h of bytes) {
+        hex += h.toString(16).padStart(2, '0');
+    }
+    return hex;
+};

package/dist/hash.test.d.ts

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

package/dist/hash.test.js

@@ -0,0 +1,25 @@
+import { suite } from 'uvu';
+import * as assert from 'uvu/assert';
+import { webcrypto } from 'node:crypto';
+import { to_hash } from './hash.js';
+/* test__to_hash */
+const test__to_hash = suite('to_hash');
+test__to_hash('turns a buffer into a string', async () => {
+    assert.type(await to_hash(Buffer.from('hey')), 'string');
+});
+test__to_hash('returns the same value given the same input', async () => {
+    assert.is(await to_hash(Buffer.from('hey')), await to_hash(Buffer.from('hey')));
+});
+test__to_hash('checks against an implementation copied from MDN', async () => {
+    const data = Buffer.from('some_test_string');
+    assert.is(await to_hash_from_mdn_example(data), await to_hash(data));
+});
+test__to_hash.run();
+/* test__to_hash */
+/**
+ * Copied from https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/digest
+ * and compared against our implementation for extra assurances, because cryptography.
+ */
+const to_hash_from_mdn_example = async (data) => Array.from(new Uint8Array(await webcrypto.subtle.digest('SHA-256', data)))
+    .map((h) => h.toString(16).padStart(2, '0'))
+    .join('');

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export type { Gro_Config, Create_Gro_Config } from './config.js';
+export { type Plugin, replace_plugin } from './plugin.js';
+export { type Gen, type Gen_Context } from './gen.js';
+export { type Task, type Task_Context, Task_Error } from './task.js';

package/dist/index.js

@@ -0,0 +1,3 @@
+export { replace_plugin } from './plugin.js';
+export {} from './gen.js';
+export { Task_Error } from './task.js';

package/dist/input_path.d.ts

@@ -0,0 +1,48 @@
+import { type Path_Data } from './path.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 declare const resolve_input_path: (raw_input_path: string) => string;
+export declare const resolve_input_paths: (raw_input_paths?: string[]) => string[];
+/**
+ * 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 declare const get_possible_source_ids: (input_path: string, extensions: string[], root_dirs?: string[]) => string[];
+/**
+ * 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 declare const load_source_path_data_by_input_path: (input_paths: string[], get_possible_source_ids_for_input_path?: ((input_path: string) => string[]) | undefined) => Promise<{
+    source_id_path_data_by_input_path: Map<string, Path_Data>;
+    unmapped_input_paths: string[];
+}>;
+/**
+ * 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 declare const load_source_ids_by_input_path: (source_id_path_data_by_input_path: Map<string, Path_Data>, custom_search_fs?: (dir: string, options?: import("./search_fs.js").Search_Fs_Options) => Promise<Map<string, import("./path.js").Path_Stats>>) => Promise<{
+    source_ids_by_input_path: Map<string, string[]>;
+    input_directories_with_no_files: string[];
+}>;