@ryanatkn/gro 0.112.0

package/dist/src_json.js

@@ -0,0 +1,110 @@
+import { z } from 'zod';
+import { join } from 'node:path';
+import { strip_start } from '@ryanatkn/belt/string.js';
+import { Project } from 'ts-morph';
+import { paths, replace_extension } from './paths.js';
+import { exists } from './fs.js';
+import { transform_empty_object_to_undefined, } from './package_json.js';
+export const Src_Module_Declaration = z
+    .object({
+    name: z.string(), // the export identifier
+    // TODO these are poorly named, and they're somewhat redundant with `kind`,
+    // they were added to distinguish `VariableDeclaration` functions and non-functions
+    kind: z.enum(['type', 'function', 'variable', 'class']).nullable(),
+    // code: z.string(), // TODO experiment with `getType().getText()`, some of them return the same as `name`
+})
+    .passthrough();
+export const Src_Module = z
+    .object({
+    path: z.string(),
+    declarations: z.array(Src_Module_Declaration),
+})
+    .passthrough();
+export const Src_Modules = z.record(Src_Module);
+/**
+ * @see https://github.com/ryanatkn/gro/blob/main/src/lib/docs/gro_plugin_sveltekit_app.md#well-known-src
+ */
+export const Src_Json = z.intersection(z.record(z.unknown()), // TODO is this what we want?
+z
+    .object({
+    name: z.string(), // same as Package_Json
+    version: z.string(), // same as Package_Json
+    modules: Src_Modules.transform(transform_empty_object_to_undefined).optional(),
+})
+    .passthrough());
+export const create_src_json = async (package_json, log, lib_path) => {
+    return Src_Json.parse({
+        name: package_json.name,
+        version: package_json.version,
+        modules: await to_src_modules(package_json.exports, log, lib_path),
+    });
+};
+export const serialize_src_json = (src_json) => {
+    const parsed = Src_Json.parse(src_json); // TODO can parse do the logic that normalize does? see `.transform`
+    return JSON.stringify(parsed, null, 2) + '\n';
+};
+export const to_src_modules = async (exports, log, lib_path = paths.lib) => {
+    if (!exports)
+        return undefined;
+    const project = new Project();
+    project.addSourceFilesAtPaths('src/**/*.ts'); // TODO dir? maybe rewrite with `lib_path`?
+    return Object.fromEntries((await Promise.all(Object.entries(exports).map(async ([k, _v]) => {
+        // TODO hacky - doesn't handle any but the normal mappings, also add a helper?
+        const source_file_path = k === '.' || k === './'
+            ? 'index.ts'
+            : strip_start(k.endsWith('.js') ? replace_extension(k, '.ts') : k, './');
+        if (!source_file_path.endsWith('.ts')) {
+            // TODO support more than just TypeScript - maybe use @sveltejs/language-tools,
+            // see how @sveltejs/package generates types, or maybe use its generated declaration files with ts-morph
+            const src_module = { path: source_file_path, declarations: [] };
+            return [k, src_module];
+        }
+        const source_file_id = join(lib_path, source_file_path);
+        if (!(await exists(source_file_id))) {
+            log?.warn('failed to infer source file from export path', k, '- the inferred file', source_file_id, 'does not exist');
+            return null;
+        }
+        const declarations = [];
+        const source_file = project.getSourceFile((f) => f.getFilePath().endsWith(source_file_path)); // TODO expected this to work without the callback, according to my read of the docs it is, but `project.getSourceFile(source_file_path)` fails
+        if (source_file) {
+            for (const [name, decls] of source_file.getExportedDeclarations()) {
+                if (!decls)
+                    continue;
+                // TODO how to correctly handle multiples?
+                for (const decl of decls) {
+                    // TODO helper
+                    const decl_type = decl.getType();
+                    const k = decl.getKindName();
+                    const kind = k === 'InterfaceDeclaration' || k === 'TypeAliasDeclaration'
+                        ? 'type'
+                        : k === 'ClassDeclaration'
+                            ? 'class'
+                            : k === 'VariableDeclaration'
+                                ? decl_type.getCallSignatures().length
+                                    ? 'function'
+                                    : 'variable' // TODO name?
+                                : null;
+                    // TODO
+                    // const code =
+                    // 	k === 'InterfaceDeclaration' || k === 'TypeAliasDeclaration'
+                    // 		? decl_type.getText(source_file) // TODO
+                    // 		: decl_type.getText(source_file);
+                    const found = declarations.find((d) => d.name === name);
+                    if (found) {
+                        // TODO hacky, this only was added to prevent `TypeAliasDeclaration` from overriding `VariableDeclaration`
+                        if (found.kind === 'type') {
+                            found.kind = kind;
+                            // found.code = code;
+                        }
+                    }
+                    else {
+                        // TODO more
+                        declarations.push({ name, kind }); // code
+                    }
+                }
+            }
+        }
+        const src_module = { path: source_file_path, declarations };
+        return [k, src_module];
+    }))).filter(Boolean));
+};

package/dist/src_json.test.d.ts

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

package/dist/src_json.test.js

@@ -0,0 +1,52 @@
+import { test } from 'uvu';
+import * as assert from 'uvu/assert';
+import { to_src_modules } from './src_json.js';
+import { to_package_exports } from './package_json.js';
+import { paths } from './paths.js';
+test('to_package_modules', async () => {
+    assert.equal(await to_src_modules(to_package_exports([
+        'fixtures/modules/some_test_css.css',
+        'fixtures/modules/Some_Test_Svelte.svelte',
+        'fixtures/modules/some_test_ts.ts',
+        'fixtures/modules/some_test_json.json',
+    ]), undefined, paths.source), {
+        './fixtures/modules/some_test_css.css': {
+            path: 'fixtures/modules/some_test_css.css',
+            declarations: [],
+        },
+        './fixtures/modules/some_test_json.json': {
+            path: 'fixtures/modules/some_test_json.json',
+            declarations: [],
+        },
+        './fixtures/modules/Some_Test_Svelte.svelte': {
+            path: 'fixtures/modules/Some_Test_Svelte.svelte',
+            declarations: [],
+        },
+        './fixtures/modules/some_test_ts.js': {
+            path: 'fixtures/modules/some_test_ts.ts',
+            declarations: [
+                {
+                    name: 'some_test_ts',
+                    kind: 'variable',
+                },
+                {
+                    name: 'some_test_fn',
+                    kind: 'function',
+                },
+                {
+                    name: 'Some_Test_Type',
+                    kind: 'type',
+                },
+                {
+                    name: 'Some_Test_Interface',
+                    kind: 'type',
+                },
+                {
+                    name: 'Some_Test_Class',
+                    kind: 'class',
+                },
+            ],
+        },
+    });
+});
+test.run();

package/dist/sveltekit_config.d.ts

@@ -0,0 +1,36 @@
+/// <reference types="svelte" />
+import type { Config as SveltekitConfig } from '@sveltejs/kit';
+import type { CompileOptions, PreprocessorGroup } from 'svelte/compiler';
+/**
+ * Loads a SvelteKit config at `dir`.
+ * @returns
+ */
+export declare const load_sveltekit_config: (dir?: string) => Promise<SveltekitConfig | null>;
+/**
+ * A subset of SvelteKit's config in a form that Gro uses
+ * because SvelteKit doesn't expose its config resolver.
+ * Flattens things out to keep them simple and easy to pass around,
+ * and doesn't deal with most properties.
+ * The `base` and `assets` in particular are renamed for clarity with Gro's internal systems,
+ * so these properties become first-class vocabulary inside Gro.
+ */
+export interface Parsed_Sveltekit_Config {
+    sveltekit_config: SveltekitConfig | null;
+    alias: Record<string, string> | undefined;
+    base_url: '' | `/${string}` | undefined;
+    assets_url: '' | `http://${string}` | `https://${string}` | undefined;
+    assets_path: string;
+    lib_path: string;
+    routes_path: string;
+    env_dir: string | undefined;
+    private_prefix: string | undefined;
+    public_prefix: string | undefined;
+    svelte_compile_options: CompileOptions | undefined;
+    svelte_preprocessors: PreprocessorGroup | PreprocessorGroup[] | undefined;
+}
+/**
+ * Returns Gro-relevant properties of a SvelteKit config
+ * as a convenience wrapper around `load_sveltekit_config`.
+ * Needed because SvelteKit doesn't expose its config resolver.
+ */
+export declare const init_sveltekit_config: (dir_or_config?: string | SveltekitConfig) => Promise<Parsed_Sveltekit_Config>;

package/dist/sveltekit_config.js

@@ -0,0 +1,51 @@
+import { join } from 'node:path';
+import { cwd } from 'node:process';
+import { SVELTEKIT_CONFIG_FILENAME } from './paths.js';
+/**
+ * Loads a SvelteKit config at `dir`.
+ * @returns
+ */
+export const load_sveltekit_config = async (dir = cwd()) => {
+    try {
+        return (await import(join(dir, SVELTEKIT_CONFIG_FILENAME))).default;
+    }
+    catch (err) {
+        return null;
+    }
+};
+// TODO currently incomplete and hack - maybe rethink
+/**
+ * Returns Gro-relevant properties of a SvelteKit config
+ * as a convenience wrapper around `load_sveltekit_config`.
+ * Needed because SvelteKit doesn't expose its config resolver.
+ */
+export const init_sveltekit_config = async (dir_or_config = cwd()) => {
+    const sveltekit_config = typeof dir_or_config === 'string' ? await load_sveltekit_config(dir_or_config) : dir_or_config;
+    const kit = sveltekit_config?.kit;
+    const alias = kit?.alias;
+    const base_url = kit?.paths?.base;
+    const assets_url = kit?.paths?.assets;
+    // TODO probably a Zod schema instead
+    const assets_path = kit?.files?.assets ?? 'static';
+    const lib_path = kit?.files?.lib ?? 'src/lib';
+    const routes_path = kit?.files?.routes ?? 'src/routes';
+    const env_dir = kit?.env?.dir;
+    const private_prefix = kit?.env?.privatePrefix;
+    const public_prefix = kit?.env?.publicPrefix;
+    const svelte_compile_options = sveltekit_config?.compilerOptions;
+    const svelte_preprocessors = sveltekit_config?.preprocess;
+    return {
+        sveltekit_config,
+        alias,
+        base_url,
+        assets_url,
+        assets_path,
+        lib_path,
+        routes_path,
+        env_dir,
+        private_prefix,
+        public_prefix,
+        svelte_compile_options,
+        svelte_preprocessors,
+    };
+};

package/dist/sveltekit_shim_app.d.ts

@@ -0,0 +1,10 @@
+import type { Parsed_Sveltekit_Config } from './sveltekit_config.js';
+export declare const sveltekit_shim_app_paths_matcher: RegExp;
+export declare const sveltekit_shim_app_environment_matcher: RegExp;
+/**
+ * Maps SvelteKit `$app` specifiers to their Gro shims.
+ * @see https://kit.svelte.dev/docs/modules
+ */
+export declare const sveltekit_shim_app_specifiers: Map<string, string>;
+export declare const render_sveltekit_shim_app_paths: (base_url?: Parsed_Sveltekit_Config['base_url'], assets_url?: Parsed_Sveltekit_Config['assets_url']) => string;
+export declare const render_sveltekit_shim_app_environment: (dev: boolean) => string;

package/dist/sveltekit_shim_app.js

@@ -0,0 +1,31 @@
+export const sveltekit_shim_app_paths_matcher = /\/util\/sveltekit_shim_app_paths\.js$/u;
+export const sveltekit_shim_app_environment_matcher = /\/util\/sveltekit_shim_app_environment\.js$/u;
+/**
+ * Maps SvelteKit `$app` specifiers to their Gro shims.
+ * @see https://kit.svelte.dev/docs/modules
+ */
+export const sveltekit_shim_app_specifiers = new Map([
+    ['$app/environment', '@ryanatkn/gro/sveltekit_shim_app_environment.js'],
+    ['$app/forms', '@ryanatkn/gro/sveltekit_shim_app_forms.js'],
+    ['$app/navigation', '@ryanatkn/gro/sveltekit_shim_app_navigation.js'],
+    ['$app/paths', '@ryanatkn/gro/sveltekit_shim_app_paths.js'],
+    ['$app/stores', '@ryanatkn/gro/sveltekit_shim_app_stores.js'],
+]);
+export const render_sveltekit_shim_app_paths = (base_url = '', assets_url = '') => `// shim for $app/paths
+// @see https://github.com/sveltejs/kit/issues/1485
+
+export const assets = ${JSON.stringify(assets_url)};
+export const base = ${JSON.stringify(base_url)};
+`;
+// TODO improve support
+// `dev` is not guaranteed to be the same as `MODE` - https://kit.svelte.dev/docs/modules#$app-environment-dev
+// `version` is `config.kit.version.name` but I couldn't see how to load a SvelteKit `ValidatedConfig`
+// `building` is just being hardcoded, might be better (but still not correct) to be `!dev`
+export const render_sveltekit_shim_app_environment = (dev) => `// shim for $app/environment
+// @see https://github.com/sveltejs/kit/issues/1485
+
+export const browser = false;
+export const building = false;
+export const dev = ${JSON.stringify(dev)};
+export const version = 'TODO';
+`;

package/dist/sveltekit_shim_app_environment.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This file is created dynamically by `render_sveltekit_shim_app_environment`
+ * but exists here for the sake of the Node loader.
+ * There may be a cleaner workaround but I couldn't find it.
+ * @see https://github.com/nodejs/loaders for details about the forthcoming virtual file support
+ */
+export declare const browser = false;
+export declare const building = false;
+export declare const dev = true;
+export declare const version = "TODO";

package/dist/sveltekit_shim_app_environment.js

@@ -0,0 +1,12 @@
+// shim for $app/environment
+// @see https://github.com/sveltejs/kit/issues/1485
+/**
+ * This file is created dynamically by `render_sveltekit_shim_app_environment`
+ * but exists here for the sake of the Node loader.
+ * There may be a cleaner workaround but I couldn't find it.
+ * @see https://github.com/nodejs/loaders for details about the forthcoming virtual file support
+ */
+export const browser = false;
+export const building = false;
+export const dev = true;
+export const version = 'TODO';

package/dist/sveltekit_shim_app_forms.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="@sveltejs/kit" />
+import type { applyAction as base_applyAction, deserialize as base_deserialize, enhance as base_enhance } from '$app/forms';
+export declare const applyAction: typeof base_applyAction;
+export declare const deserialize: typeof base_deserialize;
+export declare const enhance: typeof base_enhance;

package/dist/sveltekit_shim_app_forms.js

@@ -0,0 +1,13 @@
+// shim for $app/forms
+// @see https://github.com/sveltejs/kit/issues/1485
+import { noop, noop_async } from '@ryanatkn/belt/function.js';
+import * as devalue from 'devalue';
+export const applyAction = noop_async;
+export const deserialize = (result) => {
+    const parsed = JSON.parse(result);
+    if (parsed.data) {
+        parsed.data = devalue.parse(parsed.data);
+    }
+    return parsed;
+};
+export const enhance = () => ({ destroy: noop });

package/dist/sveltekit_shim_app_navigation.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="@sveltejs/kit" />
+import type { afterNavigate as base_afterNavigate, beforeNavigate as base_beforeNavigate, disableScrollHandling as base_disableScrollHandling, goto as base_goto, invalidate as base_invalidate, invalidateAll as base_invalidateAll, preloadCode as base_preloadCode, preloadData as base_preloadData } from '$app/navigation';
+export declare const afterNavigate: typeof base_afterNavigate;
+export declare const beforeNavigate: typeof base_beforeNavigate;
+export declare const disableScrollHandling: typeof base_disableScrollHandling;
+export declare const goto: typeof base_goto;
+export declare const invalidate: typeof base_invalidate;
+export declare const invalidateAll: typeof base_invalidateAll;
+export declare const preloadCode: typeof base_preloadCode;
+export declare const preloadData: typeof base_preloadData;

package/dist/sveltekit_shim_app_navigation.js

@@ -0,0 +1,11 @@
+// shim for $app/navigation
+// @see https://github.com/sveltejs/kit/issues/1485
+import { noop, noop_async } from '@ryanatkn/belt/function.js';
+export const afterNavigate = noop;
+export const beforeNavigate = noop;
+export const disableScrollHandling = noop;
+export const goto = noop_async;
+export const invalidate = noop_async;
+export const invalidateAll = noop_async;
+export const preloadCode = noop_async;
+export const preloadData = noop_async;

package/dist/sveltekit_shim_app_paths.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="@sveltejs/kit" />
+/**
+ * This file is created dynamically by `render_sveltekit_shim_app_paths`
+ * but exists here for the sake of the Node loader.
+ * There may be a cleaner workaround but I couldn't find it.
+ * @see https://github.com/nodejs/loaders for details about the forthcoming virtual file support
+ */
+import type { resolveRoute as base_resolveRoute } from '$app/paths';
+export declare const assets = "";
+export declare const base = "";
+export declare const resolveRoute: typeof base_resolveRoute;

package/dist/sveltekit_shim_app_paths.js

@@ -0,0 +1,6 @@
+// shim for $app/paths
+// @see https://github.com/sveltejs/kit/issues/1485
+import { noop } from '@ryanatkn/belt/function.js';
+export const assets = '';
+export const base = '';
+export const resolveRoute = noop;

package/dist/sveltekit_shim_app_stores.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="@sveltejs/kit" />
+import type { getStores as base_getStores, navigating as base_navigating, page as base_page, updated as base_updated } from '$app/stores';
+export declare const getStores: typeof base_getStores;
+export declare const navigating: typeof base_navigating;
+export declare const page: typeof base_page;
+export declare const updated: typeof base_updated;

package/dist/sveltekit_shim_app_stores.js

@@ -0,0 +1,17 @@
+// shim for $app/stores
+// @see https://github.com/sveltejs/kit/issues/1485
+import { readable } from 'svelte/store';
+export const getStores = () => ({ navigating, page, updated });
+export const navigating = readable(null);
+export const page = readable({
+    url: new URL('https://gro.ryanatkn.com/TODO'),
+    params: {},
+    route: { id: 'RouteId' },
+    status: 200,
+    error: null,
+    data: {},
+    state: {},
+    form: {},
+});
+export const updated = readable(true);
+updated.check = () => Promise.resolve(true);

package/dist/sveltekit_shim_env.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Generates a module shim for SvelteKit's `$env` imports.
+ */
+export declare const render_env_shim_module: (dev: boolean, mode: 'static' | 'dynamic', visibility: 'public' | 'private', public_prefix?: string, private_prefix?: string, env_dir?: string, env_files?: string[], ambient_env?: Record<string, string | undefined>) => Promise<string>;

package/dist/sveltekit_shim_env.js

@@ -0,0 +1,23 @@
+import { load_env } from './env.js';
+// TODO might want to do more escaping and validation
+/**
+ * Generates a module shim for SvelteKit's `$env` imports.
+ */
+export const render_env_shim_module = async (dev, mode, visibility, public_prefix = 'PUBLIC_', private_prefix = '', env_dir, env_files, ambient_env) => {
+    const env = await load_env(dev, visibility, public_prefix, private_prefix, env_dir, env_files, ambient_env);
+    if (mode === 'static') {
+        return `// shim for $env/static/${visibility}
+// @see https://github.com/sveltejs/kit/issues/1485
+${Object.entries(env)
+            .map(([k, v]) => `export let ${k} = ${JSON.stringify(v)};`)
+            .join('\n')}
+		`;
+    }
+    else {
+        return `// shim for $env/dynamic/${visibility}
+// @see https://github.com/sveltejs/kit/issues/1485
+import {load_env} from '@ryanatkn/gro/env.js';
+export const env = load_env(${dev}, ${JSON.stringify(visibility)}, ${JSON.stringify(public_prefix)}, ${JSON.stringify(private_prefix)}, ${JSON.stringify(env_dir)}, ${JSON.stringify(env_files)}, ${JSON.stringify(ambient_env)});
+		`;
+    }
+};

package/dist/sync.task.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import { type Task } from './task.js';
+export declare const Args: z.ZodObject<{
+    sveltekit: z.ZodDefault<z.ZodBoolean>;
+    'no-sveltekit': z.ZodDefault<z.ZodBoolean>;
+    package_json: z.ZodDefault<z.ZodBoolean>;
+    'no-package_json': z.ZodDefault<z.ZodBoolean>;
+    gen: z.ZodDefault<z.ZodBoolean>;
+    'no-gen': z.ZodDefault<z.ZodBoolean>;
+    install: z.ZodDefault<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    package_json: boolean;
+    sveltekit: boolean;
+    install: boolean;
+    gen: boolean;
+    'no-gen': boolean;
+    'no-package_json': boolean;
+    'no-sveltekit': boolean;
+}, {
+    sveltekit?: boolean | undefined;
+    'no-sveltekit'?: boolean | undefined;
+    package_json?: boolean | undefined;
+    'no-package_json'?: boolean | undefined;
+    gen?: boolean | undefined;
+    'no-gen'?: boolean | undefined;
+    install?: boolean | undefined;
+}>;
+export type Args = z.infer<typeof Args>;
+export declare const task: Task<Args>;
+export declare const sveltekit_sync: () => Promise<void>;

package/dist/sync.task.js

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+import { spawn } from '@ryanatkn/belt/process.js';
+import { Task_Error } from './task.js';
+import { sync_package_json } from './package_json.js';
+import { find_cli, spawn_cli } from './cli.js';
+export const Args = z
+    .object({
+    sveltekit: z.boolean({ description: 'dual of no-sveltekit' }).default(true),
+    'no-sveltekit': z.boolean({ description: 'opt out of svelte-kit sync' }).default(false),
+    package_json: z.boolean({ description: 'dual of no-package_json' }).default(true),
+    'no-package_json': z.boolean({ description: 'opt out of package.json sync' }).default(false),
+    gen: z.boolean({ description: 'dual of no-gen' }).default(true),
+    'no-gen': z.boolean({ description: 'opt out of gen sync' }).default(false),
+    install: z.boolean({ description: 'run npm install' }).default(false),
+})
+    .strict();
+export const task = {
+    summary: 'run `gro gen`, update `package.json`, and optionally `npm i` to sync up',
+    Args,
+    run: async ({ args, invoke_task, config, log }) => {
+        const { sveltekit, package_json, gen, install } = args;
+        if (install) {
+            await spawn('npm', ['i']);
+        }
+        if (sveltekit) {
+            await sveltekit_sync();
+            log.info('synced SvelteKit');
+        }
+        if (package_json && config.map_package_json) {
+            await sync_package_json(config.map_package_json, log);
+        }
+        if (gen) {
+            await invoke_task('gen');
+        }
+    },
+};
+export const sveltekit_sync = async () => {
+    if (!(await find_cli('svelte-kit'))) {
+        return;
+    }
+    const result = await spawn_cli('svelte-kit', ['sync']);
+    if (!result?.ok) {
+        throw new Task_Error(`failed svelte-kit sync`);
+    }
+};

package/dist/task.d.ts

@@ -0,0 +1,29 @@
+import type { Logger } from '@ryanatkn/belt/log.js';
+import type { z } from 'zod';
+import type { Timings } from '@ryanatkn/belt/timings.js';
+import type { Args } from './args.js';
+import type { Gro_Config } from './config.js';
+export interface Task<T_Args = Args, // same as `z.infer<typeof Args>`
+T_Args_Schema extends z.ZodType = z.ZodType, T_Return = unknown> {
+    run: (ctx: Task_Context<T_Args>) => Promise<T_Return>;
+    summary?: string;
+    Args?: T_Args_Schema;
+}
+export interface Task_Context<T_Args = object> {
+    args: T_Args;
+    config: Gro_Config;
+    log: Logger;
+    timings: Timings;
+    invoke_task: (task_name: string, args?: Args, config?: Gro_Config) => Promise<void>;
+}
+export declare const TASK_FILE_SUFFIX_TS = ".task.ts";
+export declare const TASK_FILE_SUFFIX_JS = ".task.js";
+export declare const is_task_path: (path: string) => boolean;
+export declare const to_task_name: (id: Flavored<string, "Source_Id">) => string;
+/**
+ * This is used by tasks to signal a known failure.
+ * It's useful for cleaning up logging because
+ * we usually don't need their stack trace.
+ */
+export declare class Task_Error extends Error {
+}

package/dist/task.js

@@ -0,0 +1,17 @@
+import { strip_end } from '@ryanatkn/belt/string.js';
+import { import_id_to_lib_path } from './paths.js';
+export const TASK_FILE_SUFFIX_TS = '.task.ts';
+export const TASK_FILE_SUFFIX_JS = '.task.js';
+export const is_task_path = (path) => path.endsWith(TASK_FILE_SUFFIX_TS) || path.endsWith(TASK_FILE_SUFFIX_JS);
+export const to_task_name = (id) => {
+    const lib_path = import_id_to_lib_path(id);
+    const name = strip_end(strip_end(lib_path, TASK_FILE_SUFFIX_TS), TASK_FILE_SUFFIX_JS);
+    return name;
+};
+/**
+ * This is used by tasks to signal a known failure.
+ * It's useful for cleaning up logging because
+ * we usually don't need their stack trace.
+ */
+export class Task_Error extends Error {
+}

package/dist/task.test.d.ts

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

package/dist/task.test.js

@@ -0,0 +1,22 @@
+import { suite } from 'uvu';
+import * as assert from 'uvu/assert';
+import { is_task_path, to_task_name } from './task.js';
+/* test__is_task_path */
+const test__is_task_path = suite('is_task_path');
+test__is_task_path('basic behavior', () => {
+    assert.ok(is_task_path('foo.task.ts'));
+    assert.ok(is_task_path('foo.task.js'));
+    assert.ok(!is_task_path('foo.ts'));
+    assert.ok(is_task_path('bar/baz/foo.task.ts'));
+    assert.ok(!is_task_path('bar/baz/foo.ts'));
+});
+test__is_task_path.run();
+/* test__is_task_path */
+/* test__to_task_name */
+const test__to_task_name = suite('to_task_name');
+test__to_task_name('basic behavior', () => {
+    assert.is(to_task_name('foo.task.ts'), 'foo');
+    assert.is(to_task_name('bar/baz/foo.task.ts'), 'bar/baz/foo');
+});
+test__to_task_name.run();
+/* test__to_task_name */

package/dist/task_module.d.ts

@@ -0,0 +1,14 @@
+import { load_modules, find_modules, type Module_Meta, type Load_Module_Result, type Find_Modules_Failure } from './modules.js';
+import { type Task } from './task.js';
+export interface Task_Module {
+    task: Task;
+}
+export interface Task_Module_Meta extends Module_Meta<Task_Module> {
+    name: string;
+}
+export declare const validate_task_module: (mod: Record<string, any>) => mod is Task_Module;
+export declare const load_task_module: (id: string) => Promise<Load_Module_Result<Task_Module_Meta>>;
+export declare const find_task_modules: (input_paths?: string[], extensions?: string[], root_dirs?: string[]) => Promise<ReturnType<typeof find_modules>>;
+export declare const load_task_modules: (input_paths?: string[], extensions?: string[], root_dirs?: string[]) => Promise<ReturnType<typeof load_modules<Task_Module, Task_Module_Meta>> | ({
+    ok: false;
+} & Find_Modules_Failure)>;

package/dist/task_module.js

@@ -0,0 +1,19 @@
+import { paths } from './paths.js';
+import { load_module, load_modules, find_modules, } from './modules.js';
+import { to_task_name, is_task_path, TASK_FILE_SUFFIX_TS, TASK_FILE_SUFFIX_JS, } from './task.js';
+import { get_possible_source_ids } from './input_path.js';
+import { search_fs } from './search_fs.js';
+export const validate_task_module = (mod) => !!mod.task && typeof mod.task.run === 'function';
+export const load_task_module = async (id) => {
+    const result = await load_module(id, validate_task_module);
+    if (!result.ok)
+        return result;
+    return { ...result, mod: { ...result.mod, name: to_task_name(id) } };
+};
+export const find_task_modules = async (input_paths = [paths.lib], extensions = [TASK_FILE_SUFFIX_TS, TASK_FILE_SUFFIX_JS], root_dirs) => find_modules(input_paths, (id) => search_fs(id, { filter: (path) => is_task_path(path) }), (input_path) => get_possible_source_ids(input_path, extensions, root_dirs));
+export const load_task_modules = async (input_paths, extensions, root_dirs) => {
+    const find_modules_result = await find_task_modules(input_paths, extensions, root_dirs);
+    if (!find_modules_result.ok)
+        return find_modules_result;
+    return load_modules(find_modules_result.source_ids_by_input_path, load_task_module);
+};

package/dist/task_module.test.d.ts

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