@ryanatkn/gro 0.112.0

package/dist/task_module.test.js

@@ -0,0 +1,70 @@
+import { suite } from 'uvu';
+import * as assert from 'uvu/assert';
+import { resolve } from 'node:path';
+import { validate_task_module, load_task_module, load_task_modules } from './task_module.js';
+import * as actual_test_task_module from './test.task.js';
+// TODO if we import directly, svelte-package generates types in `src/fixtures`
+/* eslint-disable no-useless-concat */
+const test_task_module = await import('../fixtures/' + 'test_task_module.task_fixture');
+const test_invalid_task_module = await import('../fixtures/' + 'test_invalid_task_module.js');
+/* test__validate_task_module */
+const test__validate_task_module = suite('validate_task_module');
+test__validate_task_module('basic behavior', () => {
+    assert.ok(validate_task_module(test_task_module));
+    assert.ok(!validate_task_module(test_invalid_task_module));
+    assert.ok(!validate_task_module({ task: { run: {} } }));
+});
+test__validate_task_module.run();
+/* test__validate_task_module */
+/* test__load_task_module */
+const test__load_task_module = suite('load_task_module');
+test__load_task_module('basic behavior', async () => {
+    const name = 'fixtures/test_task_module.task_fixture.js';
+    const id = resolve('src/' + name);
+    const result = await load_task_module(id);
+    assert.ok(result.ok);
+    assert.is(result.mod.id, id);
+    assert.is(result.mod.id, id);
+    assert.is(result.mod.name, id); // TODO was `name` but changed after scoping to lib, but we want to relax that restriction
+    assert.is(result.mod.mod, test_task_module);
+});
+test__load_task_module('invalid module', async () => {
+    const id = resolve('src/fixtures/test_invalid_task_module.js');
+    const result = await load_task_module(id);
+    assert.ok(!result.ok);
+    if (result.type === 'invalid') {
+        assert.is(result.id, id);
+        assert.is(result.mod, test_invalid_task_module);
+        assert.is(result.validation, 'validate_task_module');
+    }
+    else {
+        throw Error('should be invalid');
+    }
+});
+test__load_task_module('failing module', async () => {
+    const id = resolve('src/fixtures/test_failing_task_module.js');
+    const result = await load_task_module(id);
+    assert.ok(!result.ok);
+    if (result.type === 'importFailed') {
+        assert.is(result.id, id);
+        assert.ok(result.error);
+    }
+    else {
+        throw Error('should have failed');
+    }
+});
+test__load_task_module.run();
+/* test__load_task_module */
+/* test__load_task_modules */
+const test__load_task_modules = suite('load_task_modules');
+test__load_task_modules('basic behavior', async () => {
+    const result = await load_task_modules([
+        resolve('src/lib/test'),
+        resolve('src/lib/test.task.ts'),
+    ]);
+    assert.ok(result.ok);
+    assert.is(result.modules.length, 1);
+    assert.is(result.modules[0].mod, actual_test_task_module);
+});
+test__load_task_modules.run();
+/* test__load_task_modules */

package/dist/test.task.d.ts

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

package/dist/test.task.js

@@ -0,0 +1,43 @@
+import { yellow } from 'kleur/colors';
+import { z } from 'zod';
+import { Task_Error } from './task.js';
+import { paths } from './paths.js';
+import { find_cli } from './cli.js';
+export const Args = z
+    .object({
+    _: z.array(z.string(), { description: 'file patterns to test' }).default([`\\.test\\.ts$`]), // TODO maybe use uvu's default instead of being restrictive?
+    bail: z
+        .boolean({ description: 'the bail option to uvu run, exit immediately on failure' })
+        .default(false),
+    cwd: z.string({ description: 'the cwd option to uvu parse' }).optional(),
+    ignore: z
+        .union([z.string(), z.array(z.string())], { description: 'the ignore option to uvu parse' })
+        .optional(),
+})
+    .strict();
+export const task = {
+    summary: 'run tests with uvu',
+    Args,
+    run: async ({ args, log }) => {
+        const { _: patterns, bail, cwd, ignore } = args;
+        if (!(await find_cli('uvu'))) {
+            log.warn(yellow('uvu is not installed, skipping tests'));
+            return;
+        }
+        const { run } = await import('uvu/run');
+        const { parse } = await import('uvu/parse');
+        // uvu doesn't work with esm loaders and TypeScript files,
+        // so we use its `parse` and `run` APIs directly instead of its CLI.
+        // To avoid surprises, we allow any number of patterns in the rest args,
+        // so we call `parse` multiple times because it supports only one.
+        const suites = [];
+        for (const pattern of patterns) {
+            const parsed = await parse(paths.source, pattern, { cwd, ignore }); // eslint-disable-line no-await-in-loop
+            suites.push(...parsed.suites);
+        }
+        await run(suites, { bail });
+        if (process.exitCode) {
+            throw new Task_Error('Tests failed.');
+        }
+    },
+};

package/dist/throttle.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Throttles calls to a callback that returns a void promise.
+ * Immediately invokes the callback on the first call.
+ * If the throttled function is called while the promise is already pending,
+ * the call is queued to run after the pending promise completes plus `delay`,
+ * and only the last call is invoked.
+ * In other words, all calls and their args are discarded
+ * during the pending window except for the most recent.
+ * Unlike debouncing, this calls the throttled callback
+ * both on the leading and trailing edges of the delay window.
+ * It also differs from a queue where every call to the throttled callback eventually runs.
+ * @param cb - any function that returns a void promise
+ * @param delay - delay this many milliseconds between the pending call finishing and the next starting
+ * @returns same as `cb`
+ */
+export declare const throttle: <T extends (...args: any[]) => Promise<void>>(cb: T, delay?: number) => T;

package/dist/throttle.js

@@ -0,0 +1,59 @@
+import { wait } from '@ryanatkn/belt/async.js';
+// TODO maybe support non-promise return values?
+/**
+ * Throttles calls to a callback that returns a void promise.
+ * Immediately invokes the callback on the first call.
+ * If the throttled function is called while the promise is already pending,
+ * the call is queued to run after the pending promise completes plus `delay`,
+ * and only the last call is invoked.
+ * In other words, all calls and their args are discarded
+ * during the pending window except for the most recent.
+ * Unlike debouncing, this calls the throttled callback
+ * both on the leading and trailing edges of the delay window.
+ * It also differs from a queue where every call to the throttled callback eventually runs.
+ * @param cb - any function that returns a void promise
+ * @param delay - delay this many milliseconds between the pending call finishing and the next starting
+ * @returns same as `cb`
+ */
+export const throttle = (cb, delay = 0) => {
+    let pending_promise = null;
+    let next_args = null;
+    let next_promise = null;
+    let next_promise_resolve = null;
+    const defer = (args) => {
+        next_args = args;
+        if (!next_promise) {
+            next_promise = new Promise((resolve) => {
+                next_promise_resolve = resolve;
+            });
+        }
+        return next_promise;
+    };
+    const flush = async () => {
+        if (!next_promise_resolve)
+            return;
+        const result = await call(next_args);
+        next_args = null;
+        next_promise = null;
+        const resolve = next_promise_resolve;
+        next_promise_resolve = null;
+        resolve(result); // resolve last to prevent synchronous call issues
+    };
+    const call = (args) => {
+        pending_promise = cb(...args);
+        void pending_promise.then(async () => {
+            await wait(delay);
+            pending_promise = null;
+            await flush();
+        });
+        return pending_promise;
+    };
+    return ((...args) => {
+        if (pending_promise) {
+            return defer(args);
+        }
+        else {
+            return call(args);
+        }
+    });
+};

package/dist/throttle.test.d.ts

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

package/dist/throttle.test.js

@@ -0,0 +1,49 @@
+import { wait } from '@ryanatkn/belt/async.js';
+import { test } from 'uvu';
+import * as assert from 'uvu/assert';
+import { throttle } from './throttle.js';
+test('throttles calls to a function', async () => {
+    const results = [];
+    const fn = throttle(async (name) => {
+        results.push(name + '_run');
+        await wait();
+        results.push(name + '_done');
+    });
+    const promise_a = fn('a');
+    const promise_b = fn('b'); // discarded
+    const promise_c = fn('c'); // discarded
+    const promise_d = fn('d');
+    assert.ok(promise_a !== promise_b);
+    assert.is(promise_b, promise_c);
+    assert.is(promise_b, promise_d);
+    assert.equal(results, ['a_run']);
+    await promise_a;
+    assert.equal(results, ['a_run', 'a_done']);
+    await promise_b;
+    assert.equal(results, ['a_run', 'a_done', 'd_run', 'd_done']);
+    const promise_e = fn('e'); // discarded
+    const promise_f = fn('f');
+    assert.ok(promise_d !== promise_e);
+    assert.is(promise_e, promise_f);
+    assert.equal(results, ['a_run', 'a_done', 'd_run', 'd_done']); // delayed
+    await wait();
+    assert.equal(results, ['a_run', 'a_done', 'd_run', 'd_done', 'f_run']);
+    await promise_e;
+    assert.equal(results, ['a_run', 'a_done', 'd_run', 'd_done', 'f_run', 'f_done']);
+    const promise_g = fn('g');
+    assert.equal(results, ['a_run', 'a_done', 'd_run', 'd_done', 'f_run', 'f_done']); // delayed
+    await wait();
+    assert.equal(results, ['a_run', 'a_done', 'd_run', 'd_done', 'f_run', 'f_done', 'g_run']);
+    await promise_g;
+    assert.equal(results, [
+        'a_run',
+        'a_done',
+        'd_run',
+        'd_done',
+        'f_run',
+        'f_done',
+        'g_run',
+        'g_done',
+    ]);
+});
+test.run();

package/dist/typecheck.task.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import { type Task } from './task.js';
+export declare const Args: z.ZodObject<{}, "strict", z.ZodTypeAny, {}, {}>;
+export type Args = z.infer<typeof Args>;
+export declare const task: Task<Args>;

package/dist/typecheck.task.js

@@ -0,0 +1,38 @@
+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 { find_cli, spawn_cli } from './cli.js';
+import { sveltekit_sync } from './sync.task.js';
+export const Args = z.object({}).strict();
+export const task = {
+    summary: 'run tsc on the project without emitting any files',
+    Args,
+    run: async ({ log }) => {
+        await sveltekit_sync();
+        if (await find_cli('svelte-check')) {
+            // svelte-check
+            const serialized = serialize_args(to_forwarded_args('svelte-check'));
+            log.info(print_command_args(['svelte-check'].concat(serialized)));
+            const svelte_check_result = await spawn_cli('svelte-check', serialized);
+            if (!svelte_check_result?.ok) {
+                throw new Task_Error(`Failed to typecheck. ${print_spawn_result(svelte_check_result)}`);
+            }
+        }
+        else if (await find_cli('tsc')) {
+            // tsc
+            const forwarded = to_forwarded_args('tsc');
+            if (!forwarded.noEmit)
+                forwarded.noEmit = true;
+            const serialized = serialize_args(forwarded);
+            log.info(print_command_args(['tsc'].concat(serialized)));
+            const svelte_check_result = await spawn_cli('tsc', serialized);
+            if (!svelte_check_result?.ok) {
+                throw new Task_Error(`Failed to typecheck. ${print_spawn_result(svelte_check_result)}`);
+            }
+        }
+        else {
+            throw new Task_Error(`Failed to typecheck because neither tsc nor svelte-check was found`);
+        }
+    },
+};

package/dist/upgrade.task.d.ts

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

package/dist/upgrade.task.js

@@ -0,0 +1,37 @@
+import { spawn } from '@ryanatkn/belt/process.js';
+import { z } from 'zod';
+import { load_package_json } from './package_json.js';
+export const Args = z
+    .object({
+    _: z.array(z.string(), { description: 'names of deps to exclude from the upgrade' }).default([]),
+    dry: z.boolean({ description: 'if true, print out the planned upgrades' }).default(false),
+})
+    .strict();
+export const task = {
+    summary: 'upgrade deps',
+    Args,
+    run: async ({ args, log, invoke_task }) => {
+        const { _, dry } = args;
+        const package_json = await load_package_json();
+        const deps = to_deps(package_json).filter((d) => !_.includes(d.key));
+        const upgrade_items = to_upgrade_items(deps);
+        if (dry) {
+            log.info(`deps`, deps);
+            log.info(`upgrade_items`, upgrade_items);
+            return;
+        }
+        log.info(`upgrading:`, upgrade_items.join(' '));
+        await spawn('npm', ['i'].concat(upgrade_items));
+        await invoke_task('sync');
+    },
+};
+const to_deps = (package_json) => {
+    const prod_deps = package_json.dependencies
+        ? Object.entries(package_json.dependencies).map(([key, value]) => ({ key, value }))
+        : [];
+    const dev_deps = package_json.devDependencies
+        ? Object.entries(package_json.devDependencies).map(([key, value]) => ({ key, value }))
+        : [];
+    return prod_deps.concat(dev_deps);
+};
+const to_upgrade_items = (deps) => deps.map((dep) => dep.key + (dep.value.includes('-next.') ? '@next' : '@latest'));

package/dist/watch_dir.d.ts

@@ -0,0 +1,30 @@
+import { type WatchOptions } from 'chokidar';
+import type { Path_Stats, Path_Filter } from './path.js';
+export interface Watch_Node_Fs {
+    init: () => Promise<void>;
+    close: () => Promise<void>;
+}
+export interface Watcher_Change {
+    type: Watcher_Change_Type;
+    path: string;
+    stats: Path_Stats;
+}
+export type Watcher_Change_Type = 'create' | 'update' | 'delete';
+export interface Watcher_Change_Callback {
+    (change: Watcher_Change): void;
+}
+export interface Options {
+    dir: string;
+    on_change: Watcher_Change_Callback;
+    filter?: Path_Filter | null | undefined;
+    chokidar?: WatchOptions;
+    /**
+     * When `false`, returns the `path` relative to `dir`.
+     * @default true
+     */
+    absolute?: boolean;
+}
+/**
+ * Watch for changes on the filesystem using chokidar.
+ */
+export declare const watch_dir: ({ dir, on_change, filter, absolute, chokidar: chokidar_options, }: Options) => Watch_Node_Fs;

package/dist/watch_dir.js

@@ -0,0 +1,59 @@
+import chokidar, {} from 'chokidar';
+import { stat } from 'node:fs/promises';
+import { relative } from 'node:path';
+const FILE_STATS = { isDirectory: () => false };
+const DIR_STATS = { isDirectory: () => true };
+/**
+ * Watch for changes on the filesystem using chokidar.
+ */
+export const watch_dir = ({ dir, on_change, filter, absolute = true, chokidar: chokidar_options, }) => {
+    let watcher;
+    return {
+        init: async () => {
+            watcher = chokidar.watch(dir, chokidar_options);
+            watcher.on('add', async (path, s) => {
+                const stats = s || (await stat(path));
+                const final_path = absolute ? path : relative(dir, path);
+                if (filter && !filter(final_path, stats))
+                    return;
+                on_change({ type: 'create', path: final_path, stats });
+            });
+            watcher.on('addDir', async (path, s) => {
+                const stats = s || (await stat(path));
+                const final_path = absolute ? path : relative(dir, path);
+                if (filter && !filter(final_path, stats))
+                    return;
+                on_change({ type: 'create', path: final_path, stats });
+            });
+            watcher.on('change', async (path, s) => {
+                const stats = s || (await stat(path));
+                const final_path = absolute ? path : relative(dir, path);
+                if (filter && !filter(final_path, stats))
+                    return;
+                on_change({ type: 'update', path: final_path, stats });
+            });
+            watcher.on('unlink', (path) => {
+                const final_path = absolute ? path : relative(dir, path);
+                if (filter && !filter(final_path, FILE_STATS))
+                    return;
+                on_change({ type: 'delete', path: final_path, stats: FILE_STATS });
+            });
+            watcher.on('unlinkDir', (path) => {
+                const final_path = absolute ? path : relative(dir, path);
+                if (filter && !filter(final_path, DIR_STATS))
+                    return;
+                on_change({ type: 'delete', path: final_path, stats: DIR_STATS });
+            });
+            // wait until ready
+            let resolve;
+            const promise = new Promise((r) => (resolve = r));
+            watcher.once('ready', () => resolve());
+            await promise;
+        },
+        close: async () => {
+            if (!watcher)
+                return;
+            await watcher.close();
+        },
+    };
+};