@ryanatkn/gro 0.112.0

package/dist/esbuild_plugin_external_worker.js

@@ -0,0 +1,49 @@
+import * as esbuild from 'esbuild';
+import { basename } from 'node:path';
+import { cwd } from 'node:process';
+import { print_build_result, to_define_import_meta_env } from './esbuild_helpers.js';
+import { resolve_specifier } from './resolve_specifier.js';
+import { esbuild_plugin_sveltekit_shim_alias } from './esbuild_plugin_sveltekit_shim_alias.js';
+import { esbuild_plugin_sveltekit_shim_env } from './esbuild_plugin_sveltekit_shim_env.js';
+import { esbuild_plugin_sveltekit_shim_app } from './esbuild_plugin_sveltekit_shim_app.js';
+import { esbuild_plugin_sveltekit_local_imports } from './esbuild_plugin_sveltekit_local_imports.js';
+import { esbuild_plugin_svelte } from './esbuild_plugin_svelte.js';
+export const esbuild_plugin_external_worker = ({ dev, build_options, dir = cwd(), svelte_compile_options, svelte_preprocessors, alias, base_url, assets_url, public_prefix, private_prefix, env_dir, env_files, ambient_env, log, }) => ({
+    name: 'external_worker',
+    setup: (build) => {
+        const builds = new Map();
+        const build_worker = async (source_id) => {
+            if (builds.has(source_id))
+                return builds.get(source_id);
+            const building = esbuild.build({
+                entryPoints: [source_id],
+                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_svelte({ dir, svelte_compile_options, svelte_preprocessors }),
+                    esbuild_plugin_sveltekit_local_imports(),
+                ],
+                define: to_define_import_meta_env(dev, base_url),
+                ...build_options,
+            });
+            builds.set(source_id, building);
+            return building;
+        };
+        build.onResolve({ filter: /\.worker(|\.js|\.ts)$/u }, async ({ path, resolveDir }) => {
+            const parsed = await resolve_specifier(path, resolveDir);
+            const { specifier, source_id, namespace } = parsed;
+            const build_result = await build_worker(source_id);
+            if (log)
+                print_build_result(log, build_result);
+            return { path: './' + basename(specifier), external: true, namespace };
+        });
+    },
+});

package/dist/esbuild_plugin_svelte.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="svelte" />
+import type * as esbuild from 'esbuild';
+import { type CompileOptions, type PreprocessorGroup } from 'svelte/compiler';
+export interface Options {
+    dir?: string;
+    svelte_compile_options?: CompileOptions;
+    svelte_preprocessors?: PreprocessorGroup | PreprocessorGroup[];
+}
+export declare const esbuild_plugin_svelte: ({ dir, svelte_compile_options, svelte_preprocessors, }: Options) => esbuild.Plugin;

package/dist/esbuild_plugin_svelte.js

@@ -0,0 +1,49 @@
+import { compile, preprocess } from 'svelte/compiler';
+import { readFile } from 'node:fs/promises';
+import { relative } from 'node:path';
+import { cwd } from 'node:process';
+export const esbuild_plugin_svelte = ({ dir = cwd(), svelte_compile_options, svelte_preprocessors, }) => ({
+    name: 'svelte',
+    setup: (build) => {
+        build.onLoad({ filter: /\.svelte$/u }, async ({ path }) => {
+            let source = await readFile(path, 'utf8');
+            try {
+                const filename = relative(dir, path);
+                const preprocessed = svelte_preprocessors
+                    ? await preprocess(source, svelte_preprocessors, { filename })
+                    : null;
+                // TODO handle preprocessor sourcemaps, same as in loader - merge?
+                if (preprocessed?.code)
+                    source = preprocessed?.code;
+                const { js, warnings } = compile(source, svelte_compile_options);
+                const contents = js.map ? js.code + '//# sourceMappingURL=' + js.map.toUrl() : js.code;
+                return {
+                    contents,
+                    warnings: warnings.map((w) => to_sveltekit_message(filename, source, w)),
+                };
+            }
+            catch (err) {
+                return { errors: [to_sveltekit_message(path, source, err)] };
+            }
+        });
+    },
+});
+/**
+ * Following the example in the esbuild docs:
+ * https://esbuild.github.io/plugins/#svelte-plugin
+ */
+const to_sveltekit_message = (path, source, { message, start, end }) => {
+    let location = null;
+    if (start && end) {
+        const lineText = source.split(/\r\n|\r|\n/gu)[start.line - 1];
+        const lineEnd = start.line === end.line ? end.column : lineText.length;
+        location = {
+            file: path,
+            line: start.line,
+            lineText,
+            column: start.column,
+            length: lineEnd - start.column,
+        };
+    }
+    return { text: message, location };
+};

package/dist/esbuild_plugin_sveltekit_local_imports.d.ts

@@ -0,0 +1,7 @@
+import type * as esbuild from 'esbuild';
+/**
+ * Adds support for imports to both `.ts` and `.js`,
+ * as well as imports without extensions that resolve to `.js` or `.ts`.
+ * Prefers `.ts` over any `.js`, and falls back to `.ts` if no file is found.
+ */
+export declare const esbuild_plugin_sveltekit_local_imports: () => esbuild.Plugin;

package/dist/esbuild_plugin_sveltekit_local_imports.js

@@ -0,0 +1,30 @@
+import { readFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { resolve_specifier } from './resolve_specifier.js';
+/**
+ * Adds support for imports to both `.ts` and `.js`,
+ * as well as imports without extensions that resolve to `.js` or `.ts`.
+ * Prefers `.ts` over any `.js`, and falls back to `.ts` if no file is found.
+ */
+export const esbuild_plugin_sveltekit_local_imports = () => ({
+    name: 'sveltekit_local_imports',
+    setup: (build) => {
+        build.onResolve({ filter: /^(\/|\.)/u }, async (args) => {
+            const { path, importer } = args;
+            if (!importer)
+                return { path };
+            const { source_id, namespace } = await resolve_specifier(path, dirname(importer));
+            return { path: source_id, namespace }; // `namespace` may be `undefined`, but esbuild needs the absolute path for json etc
+        });
+        build.onLoad({ filter: /.*/u, namespace: 'sveltekit_local_imports_ts' }, async ({ path }) => ({
+            contents: await readFile(path),
+            loader: 'ts',
+            resolveDir: dirname(path),
+        }));
+        build.onLoad({ filter: /.*/u, namespace: 'sveltekit_local_imports_js' }, async ({ path }) => ({
+            contents: await readFile(path),
+            loader: 'js',
+            resolveDir: dirname(path),
+        }));
+    },
+});

package/dist/esbuild_plugin_sveltekit_shim_alias.d.ts

@@ -0,0 +1,6 @@
+import type * as esbuild from 'esbuild';
+export interface Options {
+    dir?: string;
+    alias?: Record<string, string>;
+}
+export declare const esbuild_plugin_sveltekit_shim_alias: ({ dir, alias, }: Options) => esbuild.Plugin;

package/dist/esbuild_plugin_sveltekit_shim_alias.js

@@ -0,0 +1,16 @@
+import { escape_regexp } from '@ryanatkn/belt/regexp.js';
+import { cwd } from 'node:process';
+import { join } from 'node:path';
+export const esbuild_plugin_sveltekit_shim_alias = ({ dir = cwd(), alias, }) => ({
+    name: 'sveltekit_shim_alias',
+    setup: (build) => {
+        const aliases = { $lib: 'src/lib', ...alias };
+        const alias_regexp_prefixes = Object.keys(aliases).map((a) => escape_regexp(a));
+        const filter = new RegExp('^(' + alias_regexp_prefixes.join('|') + ')', 'u');
+        build.onResolve({ filter }, async (args) => {
+            const { path, ...rest } = args;
+            const prefix = filter.exec(path)[1];
+            return build.resolve(join(dir, aliases[prefix] + path.substring(prefix.length)), rest);
+        });
+    },
+});

package/dist/esbuild_plugin_sveltekit_shim_app.d.ts

@@ -0,0 +1,8 @@
+import type * as esbuild from 'esbuild';
+import type { Parsed_Sveltekit_Config } from './sveltekit_config.js';
+export interface Options {
+    dev: boolean;
+    base_url: Parsed_Sveltekit_Config['base_url'];
+    assets_url: Parsed_Sveltekit_Config['assets_url'];
+}
+export declare const esbuild_plugin_sveltekit_shim_app: ({ dev, base_url, assets_url, }: Options) => esbuild.Plugin;

package/dist/esbuild_plugin_sveltekit_shim_app.js

@@ -0,0 +1,23 @@
+import { render_sveltekit_shim_app_environment, render_sveltekit_shim_app_paths, sveltekit_shim_app_specifiers, } from './sveltekit_shim_app.js';
+export const esbuild_plugin_sveltekit_shim_app = ({ dev, base_url, assets_url, }) => ({
+    name: 'sveltekit_shim_app',
+    setup: (build) => {
+        build.onResolve({ filter: /^\$app\/(forms|navigation|stores)$/u }, ({ path, ...rest }) => build.resolve(sveltekit_shim_app_specifiers.get(path), rest));
+        build.onResolve({ filter: /^\$app\/paths$/u }, ({ path }) => ({
+            path: sveltekit_shim_app_specifiers.get(path),
+            namespace: 'sveltekit_shim_app_paths',
+        }));
+        build.onLoad({ filter: /.*/u, namespace: 'sveltekit_shim_app_paths' }, () => ({
+            loader: 'js',
+            contents: render_sveltekit_shim_app_paths(base_url, assets_url),
+        }));
+        build.onResolve({ filter: /^\$app\/environment$/u }, ({ path }) => ({
+            path: sveltekit_shim_app_specifiers.get(path),
+            namespace: 'sveltekit_shim_app_environment',
+        }));
+        build.onLoad({ filter: /.*/u, namespace: 'sveltekit_shim_app_environment' }, () => ({
+            loader: 'js',
+            contents: render_sveltekit_shim_app_environment(dev),
+        }));
+    },
+});

package/dist/esbuild_plugin_sveltekit_shim_env.d.ts

@@ -0,0 +1,10 @@
+import type * as esbuild from 'esbuild';
+export interface Options {
+    dev: boolean;
+    public_prefix?: string;
+    private_prefix?: string;
+    env_dir?: string;
+    env_files?: string[];
+    ambient_env?: Record<string, string>;
+}
+export declare const esbuild_plugin_sveltekit_shim_env: ({ dev, public_prefix, private_prefix, env_dir, env_files, ambient_env, }: Options) => esbuild.Plugin;

package/dist/esbuild_plugin_sveltekit_shim_env.js

@@ -0,0 +1,18 @@
+import { render_env_shim_module } from './sveltekit_shim_env.js';
+export const esbuild_plugin_sveltekit_shim_env = ({ dev, public_prefix, private_prefix, env_dir, env_files, ambient_env, }) => ({
+    name: 'sveltekit_shim_env',
+    setup: (build) => {
+        const namespace = 'sveltekit_shim_env';
+        const filter = /^\$env\/(static|dynamic)\/(public|private)$/u;
+        build.onResolve({ filter }, ({ path }) => ({ path, namespace }));
+        build.onLoad({ filter: /.*/u, namespace }, async ({ path }) => {
+            const matches = filter.exec(path);
+            const mode = matches[1];
+            const visibility = matches[2];
+            return {
+                loader: 'ts',
+                contents: await render_env_shim_module(dev, mode, visibility, public_prefix, private_prefix, env_dir, env_files, ambient_env),
+            };
+        });
+    },
+});

package/dist/format.task.d.ts

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

package/dist/format.task.js

@@ -0,0 +1,24 @@
+import { print_spawn_result } from '@ryanatkn/belt/process.js';
+import { z } from 'zod';
+import { Task_Error } from './task.js';
+import { format_directory } from './format_directory.js';
+import { paths } from './paths.js';
+export const Args = z
+    .object({
+    check: z
+        .boolean({ description: 'exit with a nonzero code if any files are unformatted' })
+        .default(false),
+})
+    .strict();
+export const task = {
+    summary: 'format source files',
+    Args,
+    run: async ({ args, log }) => {
+        const { check } = args;
+        // TODO forward prettier args
+        const format_result = await format_directory(log, paths.source, check);
+        if (!format_result.ok) {
+            throw new Task_Error(`Failed ${check ? 'formatting check' : 'to format'}. ${print_spawn_result(format_result)}`);
+        }
+    },
+};

package/dist/format_directory.d.ts

@@ -0,0 +1,2 @@
+import { type Spawn_Result } from '@ryanatkn/belt/process.js';
+export declare const format_directory: (log: Logger, directory: string, check?: boolean, extensions?: string, root_paths?: string) => Promise<Spawn_Result>;

package/dist/format_directory.js

@@ -0,0 +1,27 @@
+import { spawn } from '@ryanatkn/belt/process.js';
+import { GITHUB_DIRNAME, paths, README_FILENAME, SVELTEKIT_CONFIG_FILENAME, VITE_CONFIG_FILENAME, TSCONFIG_FILENAME, CONFIG_PATH, } from './paths.js';
+import { print_command_args, serialize_args, to_forwarded_args } from './args.js';
+const DEFAULT_EXTENSIONS = 'ts,js,json,svelte,html,css,md,yml';
+const DEFAULT_ROOT_PATHS = `${[
+    README_FILENAME,
+    CONFIG_PATH,
+    SVELTEKIT_CONFIG_FILENAME,
+    VITE_CONFIG_FILENAME,
+    TSCONFIG_FILENAME,
+    GITHUB_DIRNAME,
+].join(',')}/**/*`;
+// This formats a directory on the filesystem.
+// If the source directory is given, it also formats all of the root directory files.
+// This is separated from `./format_file` to avoid importing all of the `prettier` code
+// inside modules that import this one. (which has a nontrivial cost)
+export const format_directory = (log, directory, check = false, extensions = DEFAULT_EXTENSIONS, root_paths = DEFAULT_ROOT_PATHS) => {
+    const forwarded_args = to_forwarded_args('prettier');
+    forwarded_args[check ? 'check' : 'write'] = true;
+    const serialized_args = ['prettier', ...serialize_args(forwarded_args)];
+    serialized_args.push(`${directory}**/*.{${extensions}}`);
+    if (directory === paths.source) {
+        serialized_args.push(`${paths.root}{${root_paths}}`);
+    }
+    log.info(print_command_args(serialized_args));
+    return spawn('npx', serialized_args);
+};

package/dist/format_file.d.ts

@@ -0,0 +1,8 @@
+import prettier from 'prettier';
+/**
+ * Formats a file with Prettier.
+ * @param content
+ * @param options
+ * @param base_options - defaults to the the cwd's package.json `prettier` value
+ */
+export declare const format_file: (content: string, options: prettier.Options, base_options?: prettier.Options | null | undefined) => Promise<string>;

package/dist/format_file.js

@@ -0,0 +1,42 @@
+import prettier from 'prettier';
+import { extname } from 'node:path';
+import { load_package_json } from './package_json.js';
+let cached_base_options;
+/**
+ * Formats a file with Prettier.
+ * @param content
+ * @param options
+ * @param base_options - defaults to the the cwd's package.json `prettier` value
+ */
+export const format_file = async (content, options, base_options = cached_base_options) => {
+    const final_base_options = base_options !== undefined
+        ? base_options
+        : (cached_base_options = (await load_package_json()).prettier);
+    let final_options = options;
+    if (options.filepath && !options.parser) {
+        const { filepath, ...rest } = options;
+        const parser = infer_parser(filepath);
+        if (parser)
+            final_options = { ...rest, parser };
+    }
+    try {
+        return await prettier.format(content, { ...final_base_options, ...final_options });
+    }
+    catch (err) {
+        return content;
+    }
+};
+// This is just a simple convenience for callers so they can pass a file path.
+// They can provide the Prettier `options.parser` for custom extensions.
+const infer_parser = (path) => {
+    const extension = extname(path).substring(1);
+    switch (extension) {
+        case 'svelte':
+        case 'xml': {
+            return extension;
+        }
+        default: {
+            return null;
+        }
+    }
+};

package/dist/format_file.test.d.ts

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

package/dist/format_file.test.js

@@ -0,0 +1,16 @@
+import { test } from 'uvu';
+import * as assert from 'uvu/assert';
+import { format_file } from './format_file.js';
+test('format ts', async () => {
+    const ts_unformatted = 'hey (1)';
+    const ts_formatted = 'hey(1);\n';
+    assert.is(await format_file(ts_unformatted, { filepath: 'foo.ts' }), ts_formatted);
+    assert.is(await format_file(ts_unformatted, { parser: 'typescript' }), ts_formatted);
+});
+test('format svelte', async () => {
+    const svelte_unformatted = '<style>a{color: red}</style>';
+    const svelte_formatted = '<style>\n\ta {\n\t\tcolor: red;\n\t}\n</style>\n';
+    assert.is(await format_file(svelte_unformatted, { filepath: 'foo.svelte' }), svelte_formatted);
+    assert.is(await format_file(svelte_unformatted, { parser: 'svelte' }), svelte_formatted);
+});
+test.run();

package/dist/fs.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+import type { RmOptions } from 'node:fs';
+export declare const exists: (path: string) => Promise<boolean>;
+/**
+ * Empties a directory with an optional `filter`.
+ */
+export declare const empty_dir: (dir: string, filter?: ((path: string) => boolean) | undefined, options?: RmOptions) => Promise<void>;

package/dist/fs.js

@@ -0,0 +1,19 @@
+import { access, constants, readdir, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+export const exists = async (path) => {
+    try {
+        await access(path, constants.F_OK);
+        return true;
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return false;
+        throw err;
+    }
+};
+/**
+ * Empties a directory with an optional `filter`.
+ */
+export const empty_dir = async (dir, filter, options) => {
+    await Promise.all((await readdir(dir)).map((path) => filter && !filter(path) ? null : rm(join(dir, path), { ...options, recursive: true })));
+};

package/dist/fs.test.d.ts

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

package/dist/fs.test.js

@@ -0,0 +1,16 @@
+import { test } from 'uvu';
+import * as assert from 'uvu/assert';
+import { exists } from './fs.js';
+test('file exists', async () => {
+    assert.ok(await exists('./src/lib/fs.ts'));
+});
+test('file does not exist', async () => {
+    assert.ok(!(await exists('./src/lib/existsssss.ts')));
+});
+test('directory exists', async () => {
+    assert.ok(await exists('./src/lib'));
+});
+test('directory does not exist', async () => {
+    assert.ok(!(await exists('./src/libbbbbbbb')));
+});
+test.run();

package/dist/gen.d.ts

@@ -0,0 +1,57 @@
+import type { Logger } from '@ryanatkn/belt/log.js';
+import { z } from 'zod';
+export type Gen_Result = {
+    origin_id: string;
+    files: Gen_File[];
+};
+export interface Gen_File {
+    id: string;
+    content: string;
+    origin_id: string;
+    format: boolean;
+}
+export interface Gen {
+    (ctx: Gen_Context): Raw_Gen_Result | Promise<Raw_Gen_Result>;
+}
+export interface Gen_Context {
+    origin_id: string;
+    log: Logger;
+}
+export type Raw_Gen_Result = string | Raw_Gen_File | null | Raw_Gen_Result[];
+export interface Raw_Gen_File {
+    content: string;
+    filename?: string;
+    format?: boolean;
+}
+export declare const Gen_Config: z.ZodObject<{
+    imports: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    imports: Record<string, string>;
+}, {
+    imports?: Record<string, string> | undefined;
+}>;
+export type Gen_Config = z.infer<typeof Gen_Config>;
+export type Gen_Results = {
+    results: Gen_Module_Result[];
+    successes: Gen_Module_Result_Success[];
+    failures: Gen_Module_Result_Failure[];
+    input_count: number;
+    output_count: number;
+    elapsed: number;
+};
+export type Gen_Module_Result = Gen_Module_Result_Success | Gen_Module_Result_Failure;
+export type Gen_Module_Result_Success = {
+    ok: true;
+    id: string;
+    files: Gen_File[];
+    elapsed: number;
+};
+export type Gen_Module_Result_Failure = {
+    ok: false;
+    id: string;
+    reason: string;
+    error: Error;
+    elapsed: number;
+};
+export declare const to_gen_result: (origin_id: Flavored<string, "Source_Id">, raw_result: Raw_Gen_Result) => Gen_Result;
+export declare const to_output_file_name: (filename: string) => string;

package/dist/gen.js

@@ -0,0 +1,81 @@
+import { join, basename, dirname, isAbsolute } from 'node:path';
+import { z } from 'zod';
+import { gen_module_meta, to_gen_module_type } from './gen_module.js';
+export const Gen_Config = z.object({
+    imports: z.record(z.string(), z.string()).default({}),
+});
+export const to_gen_result = (origin_id, raw_result) => {
+    return {
+        origin_id,
+        files: to_gen_files(origin_id, raw_result),
+    };
+};
+const to_gen_files = (origin_id, raw_result) => {
+    if (raw_result === null) {
+        return [];
+    }
+    else if (typeof raw_result === 'string') {
+        return [to_gen_file(origin_id, { content: raw_result })];
+    }
+    else if (Array.isArray(raw_result)) {
+        const files = raw_result.flatMap((f) => to_gen_files(origin_id, f));
+        validate_gen_files(files);
+        return files;
+    }
+    return [to_gen_file(origin_id, raw_result)];
+};
+const to_gen_file = (origin_id, raw_gen_file) => {
+    const { content, filename, format = true } = raw_gen_file;
+    const id = to_output_file_id(origin_id, filename);
+    return { id, content, origin_id, format };
+};
+const to_output_file_id = (origin_id, raw_file_name) => {
+    if (raw_file_name === '') {
+        throw Error(`Output file name cannot be an empty string`);
+    }
+    const filename = raw_file_name || to_output_file_name(basename(origin_id));
+    if (isAbsolute(filename))
+        return filename;
+    const dir = dirname(origin_id);
+    const output_file_id = join(dir, filename);
+    if (output_file_id === origin_id) {
+        throw Error('Gen origin and output file ids cannot be the same');
+    }
+    return output_file_id;
+};
+export const to_output_file_name = (filename) => {
+    const { pattern, text } = gen_module_meta[to_gen_module_type(filename)];
+    const parts = filename.split('.');
+    const gen_pattern_index = parts.indexOf(text);
+    if (gen_pattern_index === -1) {
+        throw Error(`Invalid gen file name - '${text}' not found in '${filename}'`);
+    }
+    if (gen_pattern_index !== parts.lastIndexOf(text)) {
+        throw Error(`Invalid gen file name - multiple instances of '${text}' found in '${filename}'`);
+    }
+    if (gen_pattern_index < parts.length - 3) {
+        // This check is technically unneccessary,
+        // but ensures a consistent file naming convention.
+        throw Error(`Invalid gen file name - only one additional extension is allowed to follow '${pattern}' in '${filename}'`);
+    }
+    const final_parts = [];
+    const has_different_ext = gen_pattern_index === parts.length - 3;
+    const length = has_different_ext ? parts.length - 1 : parts.length;
+    for (let i = 0; i < length; i++) {
+        if (i === gen_pattern_index)
+            continue; // skip the `.gen.` pattern
+        if (i === length - 1 && parts[i] === '')
+            continue; // allow empty extension
+        final_parts.push(parts[i]);
+    }
+    return final_parts.join('.');
+};
+const validate_gen_files = (files) => {
+    const ids = new Set();
+    for (const file of files) {
+        if (ids.has(file.id)) {
+            throw Error(`Duplicate gen file id: ${file.id}`);
+        }
+        ids.add(file.id);
+    }
+};

package/dist/gen.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">>;
+    check: z.ZodDefault<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    _: string[];
+    check: boolean;
+}, {
+    _?: string[] | undefined;
+    check?: boolean | undefined;
+}>;
+export type Args = z.infer<typeof Args>;
+export declare const task: Task<Args>;