@ryanatkn/gro 0.112.0

package/dist/paths.d.ts

@@ -0,0 +1,60 @@
+import type { Flavored } from '@ryanatkn/belt/types.js';
+import { z } from 'zod';
+export declare const SOURCE_DIRNAME = "src";
+export declare const GRO_DIRNAME = ".gro";
+export declare const GRO_DIST_PREFIX = "dist_";
+export declare const SERVER_DIST_PATH = "dist_server";
+export declare const LIB_DIRNAME = "lib";
+export declare const ROUTES_DIRNAME = "routes";
+export declare const GRO_DEV_DIRNAME: string;
+export declare const SOURCE_DIR: string;
+export declare const GRO_DIR: string;
+export declare const GRO_DEV_DIR: string;
+export declare const LIB_PATH: string;
+export declare const LIB_DIR: string;
+export declare const CONFIG_PATH = "gro.config.ts";
+export declare const README_FILENAME = "README.md";
+export declare const SVELTEKIT_CONFIG_FILENAME = "svelte.config.js";
+export declare const VITE_CONFIG_FILENAME = "vite.config.ts";
+export declare const SVELTEKIT_DEV_DIRNAME = ".svelte-kit";
+export declare const SVELTEKIT_BUILD_DIRNAME = "build";
+export declare const SVELTEKIT_DIST_DIRNAME = "dist";
+export declare const NODE_MODULES_DIRNAME = "node_modules";
+export declare const SVELTEKIT_VITE_CACHE_PATH: string;
+export declare const GITHUB_DIRNAME = ".github";
+export declare const GIT_DIRNAME = ".git";
+export declare const TSCONFIG_FILENAME = "tsconfig.json";
+export interface Paths {
+    root: string;
+    source: string;
+    lib: string;
+    build: string;
+    build_dev: string;
+    config: string;
+}
+export declare const Url: z.ZodString;
+export type Url = Flavored<z.infer<typeof Url>, 'Url'>;
+export declare const Email: z.ZodString;
+export type Email = Flavored<z.infer<typeof Email>, 'Email'>;
+export declare const Source_Id: z.ZodString;
+export type Source_Id = Flavored<z.infer<typeof Source_Id>, 'Source_Id'>;
+export declare const Build_Id: z.ZodString;
+export type Build_Id = Flavored<z.infer<typeof Build_Id>, 'Build_Id'>;
+export declare const create_paths: (root_dir: string) => Paths;
+export declare const paths_from_id: (id: string) => Paths;
+export declare const is_gro_id: (id: string) => boolean;
+export declare const to_root_path: (id: string, p?: Paths) => string;
+export declare const source_id_to_base_path: (source_id: Flavored<string, "Source_Id">, p?: Paths) => string;
+export declare const base_path_to_source_id: (base_path: string, p?: Paths) => Flavored<string, "Source_Id">;
+export declare const lib_path_to_import_id: (base_path: string, p?: Paths) => Flavored<string, "Source_Id">;
+export declare const import_id_to_lib_path: (import_id: string, p?: Paths) => string;
+export declare const to_gro_input_path: (input_path: string) => string;
+export declare const replace_root_dir: (id: string, root_dir: string, p?: Paths) => string;
+export declare const print_path: (path: string, p?: Paths, prefix?: string) => string;
+export declare const print_path_or_gro_path: (path: string, from_paths?: Paths) => string;
+export declare const replace_extension: (path: string, new_extension: string) => string;
+export declare const gro_dir_basename: string;
+export declare const paths: Paths;
+export declare const is_this_project_gro: boolean;
+export declare const gro_paths: Paths;
+export declare const gro_sveltekit_dist_dir: string;

package/dist/paths.js

@@ -0,0 +1,128 @@
+import { join, basename, extname, relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { strip_end, strip_start } from '@ryanatkn/belt/string.js';
+import { gray } from 'kleur/colors';
+import { z } from 'zod';
+/*
+
+A path `id` is an absolute path to the source/.gro/dist directory.
+It's the same nomenclature that Rollup uses.
+
+A `base_path` is the format used by `CheapWatch`.
+It's a bare relative path without a source or .gro directory,
+e.g. 'foo/bar.ts'.
+
+`CheapWatch` also uses an array of `path_parts`.
+For path './foo/bar/baz.ts',
+the `path_parts` are `['foo', 'foo/bar', 'foo/bar/baz.ts']`.
+
+*/
+// TODO pass these to `create_paths` and override from gro config
+// TODO this is kinda gross - do we want to maintain the convention to have the trailing slash in most usage?
+export const SOURCE_DIRNAME = 'src';
+export const GRO_DIRNAME = '.gro';
+export const GRO_DIST_PREFIX = 'dist_'; //
+export const SERVER_DIST_PATH = 'dist_server'; // TODO should all of these be `_PATH` or should this be `DIRNAME`?
+export const LIB_DIRNAME = 'lib'; // TODO use Svelte config `files.lib`
+export const ROUTES_DIRNAME = 'routes'; // TODO use Svelte config `files.lib`
+export const GRO_DEV_DIRNAME = GRO_DIRNAME + '/dev';
+export const SOURCE_DIR = SOURCE_DIRNAME + '/';
+export const GRO_DIR = GRO_DIRNAME + '/';
+export const GRO_DEV_DIR = GRO_DEV_DIRNAME + '/';
+export const LIB_PATH = SOURCE_DIR + LIB_DIRNAME;
+export const LIB_DIR = LIB_PATH + '/'; // TODO @multiple get from the sveltekit config
+export const CONFIG_PATH = 'gro.config.ts';
+export const README_FILENAME = 'README.md';
+export const SVELTEKIT_CONFIG_FILENAME = 'svelte.config.js';
+export const VITE_CONFIG_FILENAME = 'vite.config.ts';
+export const SVELTEKIT_DEV_DIRNAME = '.svelte-kit'; // TODO use Svelte config value `outDir`
+export const SVELTEKIT_BUILD_DIRNAME = 'build';
+export const SVELTEKIT_DIST_DIRNAME = 'dist';
+export const NODE_MODULES_DIRNAME = 'node_modules';
+export const SVELTEKIT_VITE_CACHE_PATH = NODE_MODULES_DIRNAME + '/.vite';
+export const GITHUB_DIRNAME = '.github';
+export const GIT_DIRNAME = '.git';
+export const TSCONFIG_FILENAME = 'tsconfig.json';
+// TODO upstream to util, and probably add `Path`/`FilePath` and `FileUrl`
+export const Url = z.string();
+export const Email = z.string();
+export const Source_Id = z.string();
+export const Build_Id = z.string();
+export const create_paths = (root_dir) => {
+    // TODO remove reliance on trailing slash towards windows support
+    const root = strip_end(root_dir, '/') + '/';
+    return {
+        root,
+        source: root + SOURCE_DIR,
+        lib: root + LIB_DIR, // TODO @multiple get from the sveltekit config
+        build: root + GRO_DIR,
+        build_dev: root + GRO_DEV_DIR,
+        config: root + CONFIG_PATH,
+    };
+};
+export const paths_from_id = (id) => (is_gro_id(id) ? gro_paths : paths);
+export const is_gro_id = (id) => id.startsWith(gro_paths.root);
+// TODO maybe infer `p` for the functions that take in ids using `paths_from_id`?
+// '/home/me/app/src/foo/bar/baz.ts' → 'src/foo/bar/baz.ts'
+export const to_root_path = (id, p = paths) => strip_start(id, p.root);
+// '/home/me/app/src/foo/bar/baz.ts' → 'foo/bar/baz.ts'
+export const source_id_to_base_path = (source_id, p = paths) => relative(p.source, source_id);
+// TODO base_path is an obsolete concept, it was a remnant from forcing `src/`
+// 'foo/bar/baz.ts' → '/home/me/app/src/foo/bar/baz.ts'
+export const base_path_to_source_id = (base_path, p = paths) => join(p.source, base_path);
+// To run Gro's tasks from its own project, we resolve from dist/ instead of src/.
+// 'foo/bar/baz.ts' → '/home/me/app/src/lib/foo/bar/baz.ts'
+// 'foo/bar/baz.ts' → '/home/me/app/dist/foo/bar/baz.ts'
+export const lib_path_to_import_id = (base_path, p = paths) => {
+    if (p.root === gro_paths.root) {
+        return p.root + 'dist/' + base_path;
+    }
+    else {
+        return base_path_to_source_id(LIB_DIRNAME + '/' + base_path, p);
+    }
+};
+// An `import_id` can be a source_id in a project,
+// or a Gro source_id when running inside Gro,
+// or a `gro/dist/` file id in node_modules when inside another project.
+export const import_id_to_lib_path = (import_id, p = paths_from_id(import_id)) => {
+    if (p.root === gro_paths.root) {
+        const stripped = strip_start(strip_start(import_id, p.lib), gro_sveltekit_dist_dir); // TODO hacky, needs more work to clarify related things
+        const lib_path = is_this_project_gro ? stripped : replace_extension(stripped, '.ts');
+        return lib_path;
+    }
+    else {
+        return strip_start(import_id, p.lib);
+    }
+};
+export const to_gro_input_path = (input_path) => {
+    const base_path = input_path === paths.lib.slice(0, -1) ? '' : strip_start(input_path, paths.lib);
+    return gro_sveltekit_dist_dir + base_path;
+};
+// Can be used to map a source id from e.g. the cwd to gro's.
+export const replace_root_dir = (id, root_dir, p = paths) => join(root_dir, to_root_path(id, p));
+export const print_path = (path, p = paths, prefix = './') => {
+    const root_path = path === gro_sveltekit_dist_dir ? 'gro' : to_root_path(path, p);
+    return gray(`${prefix}${root_path}`);
+};
+export const print_path_or_gro_path = (path, from_paths = paths) => {
+    const inferred_paths = paths_from_id(path);
+    if (from_paths === gro_paths || inferred_paths === from_paths) {
+        return print_path(path, inferred_paths, '');
+    }
+    return print_path(path, gro_paths, '');
+};
+export const replace_extension = (path, new_extension) => {
+    const { length } = extname(path);
+    return (length === 0 ? path : path.substring(0, path.length - length)) + new_extension;
+};
+const filename = fileURLToPath(import.meta.url);
+const gro_dir = join(filename, filename.includes('/gro/src/lib/')
+    ? '../../../'
+    : filename.includes('/gro/dist/')
+        ? '../../'
+        : '../');
+export const gro_dir_basename = basename(gro_dir) + '/';
+export const paths = create_paths(process.cwd() + '/');
+export const is_this_project_gro = gro_dir === paths.root;
+export const gro_paths = is_this_project_gro ? paths : create_paths(gro_dir);
+export const gro_sveltekit_dist_dir = gro_paths.root + SVELTEKIT_DIST_DIRNAME + '/';

package/dist/paths.test.d.ts

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

package/dist/paths.test.js

@@ -0,0 +1,49 @@
+import { suite } from 'uvu';
+import * as assert from 'uvu/assert';
+import { resolve, join } from 'node:path';
+import { create_paths, paths, gro_paths, is_gro_id, to_root_path, source_id_to_base_path, base_path_to_source_id, } from './paths.js';
+/* test__create_paths */
+const test__create_paths = suite('create_paths');
+test__create_paths('basic behavior', () => {
+    const root = resolve('../fake');
+    const p = create_paths(root);
+    assert.is(p.root, join(root, '/'));
+    assert.is(p.source, join(root, 'src/'));
+});
+test__create_paths('paths object has the same identity as the gro_paths object', () => {
+    assert.is(paths, gro_paths); // because we're testing inside the Gro project
+});
+test__create_paths.run();
+/* test__create_paths */
+/* test__is_gro_id */
+const test__is_gro_id = suite('is_gro_id');
+test__is_gro_id('basic behavior', () => {
+    assert.ok(is_gro_id(resolve(paths.source)));
+    assert.ok(!is_gro_id(resolve('../fake/src')));
+});
+test__is_gro_id.run();
+/* test__is_gro_id */
+/* test__to_root_path */
+const test__to_root_path = suite('to_root_path');
+test__to_root_path('basic behavior', () => {
+    assert.is(to_root_path(resolve('foo/bar')), 'foo/bar');
+});
+test__to_root_path.run();
+/* test__to_root_path */
+/* test__source_id_to_base_path */
+const test__source_id_to_base_path = suite('source_id_to_base_path');
+test__source_id_to_base_path('basic behavior', () => {
+    assert.is(source_id_to_base_path(resolve('src/foo/bar/baz.ts')), 'foo/bar/baz.ts');
+});
+test__source_id_to_base_path.run();
+/* test__source_id_to_base_path */
+/* test__base_path_to_source_id */
+const test__base_path_to_source_id = suite('base_path_to_source_id');
+test__base_path_to_source_id('basic behavior', () => {
+    assert.is(base_path_to_source_id('foo/bar/baz.ts'), resolve('src/foo/bar/baz.ts'));
+});
+test__base_path_to_source_id('does not change extension', () => {
+    assert.is(base_path_to_source_id('foo/bar/baz.js'), resolve('src/foo/bar/baz.js'));
+});
+test__base_path_to_source_id.run();
+/* test__base_path_to_source_id */

package/dist/plugin.d.ts

@@ -0,0 +1,36 @@
+import type { Task_Context } from './task.js';
+/**
+ * Gro `Plugin`s enable custom behavior during `gro dev` and `gro build`.
+ * In contrast, `Adapter`s use the results of `gro build` to produce final artifacts.
+ */
+export interface Plugin<T_Plugin_Context extends Plugin_Context = Plugin_Context> {
+    name: string;
+    setup?: (ctx: T_Plugin_Context) => void | Promise<void>;
+    adapt?: (ctx: T_Plugin_Context) => void | Promise<void>;
+    teardown?: (ctx: T_Plugin_Context) => void | Promise<void>;
+}
+export interface Create_Config_Plugins<T_Plugin_Context extends Plugin_Context = Plugin_Context> {
+    (ctx: T_Plugin_Context): (Plugin<T_Plugin_Context> | null | Array<Plugin<T_Plugin_Context> | null>) | Promise<Plugin<T_Plugin_Context> | null | Array<Plugin<T_Plugin_Context> | null>>;
+}
+export interface Plugin_Context<T_Args = object> extends Task_Context<T_Args> {
+    dev: boolean;
+    watch: boolean;
+}
+export declare class Plugins<T_Plugin_Context extends Plugin_Context> {
+    private ctx;
+    private instances;
+    constructor(ctx: T_Plugin_Context, instances: Plugin[]);
+    static create<T_Plugin_Context extends Plugin_Context>(ctx: T_Plugin_Context): Promise<Plugins<T_Plugin_Context>>;
+    setup(): Promise<void>;
+    adapt(): Promise<void>;
+    teardown(): Promise<void>;
+}
+/**
+ * Replaces a plugin by name in `plugins` without mutating the param.
+ * Throws if the plugin name cannot be found.
+ * @param plugins - accepts the same types as the return value of `Create_Config_Plugins`
+ * @param new_plugin
+ * @param name - @default new_plugin.name
+ * @returns `plugins` with `new_plugin` at the index of the plugin with `name`
+ */
+export declare const replace_plugin: <T_Plugins extends T_Plugin | (T_Plugin | null)[] | null, T_Plugin extends Plugin<Plugin_Context<object>>>(plugins: T_Plugins, new_plugin: Plugin, name?: string) => T_Plugin[];

package/dist/plugin.js

@@ -0,0 +1,80 @@
+import { to_array } from '@ryanatkn/belt/array.js';
+export class Plugins {
+    ctx;
+    instances;
+    /* prefer `Plugins.create` to the constructor */
+    constructor(ctx, instances) {
+        this.ctx = ctx;
+        this.instances = instances;
+    }
+    static async create(ctx) {
+        const { timings } = ctx;
+        const timing_to_create = timings.start('plugins.create');
+        const instances = to_array(await ctx.config.plugins(ctx)).filter(Boolean);
+        const plugins = new Plugins(ctx, instances);
+        timing_to_create();
+        return plugins;
+    }
+    async setup() {
+        const { ctx, instances } = this;
+        if (!instances.length)
+            return;
+        const { timings, log } = ctx;
+        const timing_to_setup = timings.start('plugins.setup');
+        for (const plugin of instances) {
+            if (!plugin.setup)
+                continue;
+            log.debug('setup plugin', plugin.name);
+            const timing = timings.start(`setup:${plugin.name}`);
+            await plugin.setup(ctx); // eslint-disable-line no-await-in-loop
+            timing();
+        }
+        timing_to_setup();
+    }
+    async adapt() {
+        const { ctx, instances } = this;
+        const { timings } = ctx;
+        const timing_to_run_adapters = timings.start('plugins.adapt');
+        for (const plugin of instances) {
+            if (!plugin.adapt)
+                continue;
+            const timing = timings.start(`adapt:${plugin.name}`);
+            await plugin.adapt(ctx); // eslint-disable-line no-await-in-loop
+            timing();
+        }
+        timing_to_run_adapters();
+    }
+    async teardown() {
+        const { ctx, instances } = this;
+        if (!instances.length)
+            return;
+        const { timings, log } = ctx;
+        const timing_to_teardown = timings.start('plugins.teardown');
+        for (const plugin of instances) {
+            if (!plugin.teardown)
+                continue;
+            log.debug('teardown plugin', plugin.name);
+            const timing = timings.start(`teardown:${plugin.name}`);
+            await plugin.teardown(ctx); // eslint-disable-line no-await-in-loop
+            timing();
+        }
+        timing_to_teardown();
+    }
+}
+/**
+ * Replaces a plugin by name in `plugins` without mutating the param.
+ * Throws if the plugin name cannot be found.
+ * @param plugins - accepts the same types as the return value of `Create_Config_Plugins`
+ * @param new_plugin
+ * @param name - @default new_plugin.name
+ * @returns `plugins` with `new_plugin` at the index of the plugin with `name`
+ */
+export const replace_plugin = (plugins, new_plugin, name = new_plugin.name) => {
+    const array = to_array(plugins).filter(Boolean);
+    const index = array.findIndex((p) => p.name === name);
+    if (index === -1)
+        throw Error('Failed to find plugin to replace: ' + name);
+    const replaced = array.slice();
+    replaced[index] = new_plugin;
+    return replaced;
+};

package/dist/plugin.test.d.ts

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

package/dist/plugin.test.js

@@ -0,0 +1,54 @@
+import { test } from 'uvu';
+import * as assert from 'uvu/assert';
+import { replace_plugin } from './plugin.js';
+test('replace_plugin', async () => {
+    const a = { name: 'a' };
+    const b = { name: 'b' };
+    const c = { name: 'c' };
+    const plugins = [a, b, c];
+    const a2 = { name: 'a' };
+    const b2 = { name: 'b' };
+    const c2 = { name: 'c' };
+    let p = plugins;
+    p = replace_plugin(p, a2);
+    assert.is(p[0], a2);
+    assert.is(p[1], b);
+    assert.is(p[2], c);
+    p = replace_plugin(p, b2);
+    assert.is(p[0], a2);
+    assert.is(p[1], b2);
+    assert.is(p[2], c);
+    // allows duplicate names in the array
+    p = replace_plugin(p, c2, 'a');
+    assert.is(p[0], c2);
+    assert.is(p[1], b2);
+    assert.is(p[2], c);
+    p = replace_plugin(p, a2, 'c');
+    assert.is(p[0], a2);
+    assert.is(p[1], b2);
+    assert.is(p[2], c);
+    p = replace_plugin(p, c2);
+    assert.is(p[0], a2);
+    assert.is(p[1], b2);
+    assert.is(p[2], c2);
+});
+test('replace_plugin without an array', async () => {
+    const a = { name: 'a' };
+    const a2 = { name: 'a' };
+    const p = replace_plugin(a, a2);
+    assert.is(p[0], a2);
+});
+test('replace_plugin throws if it cannot find the given name', async () => {
+    const a = { name: 'a' };
+    const plugins = [a];
+    let err;
+    try {
+        replace_plugin(plugins, { name: 'b' });
+    }
+    catch (_err) {
+        err = _err;
+    }
+    if (!err)
+        assert.unreachable('should have failed');
+});
+test.run();

package/dist/print_task.d.ts

@@ -0,0 +1,4 @@
+import { type Task_Module_Meta } from './task_module.js';
+export declare const log_available_tasks: (log: Logger, dir_label: string, source_ids_by_input_path: Map<string, string[]>, print_intro?: boolean) => Promise<void>;
+export declare const log_error_reasons: (log: Logger, reasons: string[]) => void;
+export declare const print_task_help: (log: Logger, meta: Task_Module_Meta) => void;

package/dist/print_task.js

@@ -0,0 +1,124 @@
+import { cyan, gray, green, red } from 'kleur/colors';
+import { plural } from '@ryanatkn/belt/string.js';
+import { print_value } from '@ryanatkn/belt/print.js';
+import { ZodFirstPartyTypeKind } from 'zod';
+import { load_modules } from './modules.js';
+import { load_task_module } from './task_module.js';
+export const log_available_tasks = async (log, dir_label, source_ids_by_input_path, print_intro = true) => {
+    const source_ids = Array.from(source_ids_by_input_path.values()).flat();
+    if (source_ids.length) {
+        // Load all of the tasks so we can print their summary, and args for the `--help` flag.
+        const load_modules_result = await load_modules(source_ids_by_input_path, load_task_module);
+        if (!load_modules_result.ok) {
+            log_error_reasons(log, load_modules_result.reasons);
+            process.exit(1);
+        }
+        const printed = [
+            `${print_intro ? '\n\n' : ''}${source_ids.length} task${plural(source_ids.length)} in ${dir_label}:\n`,
+        ];
+        if (print_intro) {
+            printed.unshift(`\n\n${gray('Run a task:')} gro [name]`, `\n${gray('View help:')}  gro [name] --help`);
+        }
+        const longest_task_name = to_max_length(load_modules_result.modules, (m) => m.name);
+        for (const meta of load_modules_result.modules) {
+            printed.push('\n' + cyan(pad(meta.name, longest_task_name)), '  ', meta.mod.task.summary || '');
+        }
+        log[print_intro ? 'info' : 'plain'](printed.join('') + '\n');
+    }
+    else {
+        log.info(`No tasks found in ${dir_label}.`);
+    }
+};
+export const log_error_reasons = (log, reasons) => {
+    for (const reason of reasons) {
+        log.error(red(reason));
+    }
+};
+const ARGS_PROPERTY_NAME = '[...args]';
+export const print_task_help = (log, meta) => {
+    const { name, mod: { task }, } = meta;
+    const printed = [];
+    printed.push(cyan(name), 'help', cyan(`\n\ngro ${name}`) + `: ${task.summary || '(no summary available)'}\n`);
+    if (task.Args) {
+        const properties = to_arg_properties(task.Args._def, meta);
+        // TODO hacky padding for some quick and dirty tables
+        const longest_task_name = Math.max(ARGS_PROPERTY_NAME.length, to_max_length(properties, (p) => p.name));
+        const longest_type = to_max_length(properties, (p) => p.schema.type);
+        const longest_default = to_max_length(properties, (p) => print_value(p.schema.default));
+        for (const property of properties) {
+            const name = property.name === '_' ? ARGS_PROPERTY_NAME : property.name;
+            printed.push(`\n${green(pad(name, longest_task_name))} `, gray(pad(property.schema.type, longest_type)) + ' ', pad(print_value(property.schema.default), longest_default) + ' ', property.schema.description || '(no description available)');
+        }
+        if (!properties.length) {
+            printed.push('\n' + gray('this task has no args'));
+        }
+    }
+    log.info(...printed, '\n');
+};
+const to_arg_properties = (def, meta) => {
+    const type_name = to_type_name(def);
+    if (type_name !== ZodFirstPartyTypeKind.ZodObject) {
+        throw Error(`Expected Args for task "${meta.name}" to be a ZodObject schema but got ${type_name}`);
+    }
+    const shape = def.shape();
+    const properties = [];
+    for (const name in shape) {
+        if ('no-' + name in shape)
+            continue;
+        const s = shape[name];
+        const schema = {
+            type: to_args_schema_type(s),
+            description: to_args_schema_description(s),
+            default: to_args_schema_default(s),
+        };
+        properties.push({ name, schema });
+    }
+    return properties;
+};
+// quick n dirty padding logic
+const pad = (s, n) => s + ' '.repeat(n - s.length);
+const to_max_length = (items, toString) => items.reduce((max, m) => Math.max(toString(m).length, max), 0);
+// The following Zod helpers only need to support single-depth schemas for CLI args,
+// but there's generic recursion to handle things like `ZodOptional` and `ZodDefault`.
+const to_type_name = (def) => def.typeName;
+const to_args_schema_type = ({ _def }) => {
+    const t = to_type_name(_def);
+    switch (t) {
+        case ZodFirstPartyTypeKind.ZodBoolean:
+            return 'boolean';
+        case ZodFirstPartyTypeKind.ZodString:
+            return 'string';
+        case ZodFirstPartyTypeKind.ZodNumber:
+            return 'number';
+        case ZodFirstPartyTypeKind.ZodArray:
+            return 'string[]'; // TODO support arrays of arbitrary types, or more hardcoded ones as needed
+        case ZodFirstPartyTypeKind.ZodEnum:
+            return _def.values.map((v) => `'${v}'`).join(' | ');
+        case ZodFirstPartyTypeKind.ZodUnion:
+            return 'string | string[]'; // TODO support unions of arbitrary types, or more hardcoded ones as needed
+        default: {
+            if ('innerType' in _def) {
+                return to_args_schema_type(_def.innerType);
+            }
+            else {
+                throw Error('Unknown zod type ' + t);
+            }
+        }
+    }
+};
+const to_args_schema_description = ({ _def }) => {
+    if (_def.description)
+        return _def.description;
+    if ('innerType' in _def) {
+        return to_args_schema_description(_def.innerType);
+    }
+    return '';
+};
+const to_args_schema_default = ({ _def }) => {
+    if (_def.defaultValue)
+        return _def.defaultValue();
+    if ('innerType' in _def) {
+        return to_args_schema_default(_def.innerType);
+    }
+    return undefined;
+};

package/dist/publish.task.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import { type Task } from './task.js';
+export declare const Args: z.ZodObject<{
+    branch: z.ZodDefault<z.ZodString>;
+    changelog: z.ZodDefault<z.ZodString>;
+    preserve_changelog: z.ZodDefault<z.ZodBoolean>;
+    dry: z.ZodDefault<z.ZodBoolean>;
+    check: z.ZodDefault<z.ZodBoolean>;
+    'no-check': z.ZodDefault<z.ZodBoolean>;
+    install: z.ZodDefault<z.ZodBoolean>;
+    'no-install': z.ZodDefault<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    install: boolean;
+    branch: string;
+    changelog: string;
+    'no-install': boolean;
+    check: boolean;
+    dry: boolean;
+    preserve_changelog: boolean;
+    'no-check': boolean;
+}, {
+    branch?: string | undefined;
+    changelog?: string | undefined;
+    preserve_changelog?: boolean | undefined;
+    dry?: boolean | undefined;
+    check?: boolean | undefined;
+    'no-check'?: boolean | undefined;
+    install?: boolean | undefined;
+    'no-install'?: boolean | undefined;
+}>;
+export type Args = z.infer<typeof Args>;
+export declare const task: Task<Args>;