@ryanatkn/gro 0.112.0

package/dist/changelog.test.js

@@ -0,0 +1,118 @@
+import { test } from 'uvu';
+import * as assert from 'uvu/assert';
+import { Logger } from '@ryanatkn/belt/log.js';
+import { readFile, writeFile } from 'fs/promises';
+import { update_changelog } from './changelog.js';
+import { load_from_env } from './env.js';
+const log = new Logger();
+const token = await load_from_env('GITHUB_TOKEN_SECRET');
+if (!token) {
+    log.warn('the env var GITHUB_TOKEN_SECRET was not found, so API calls with be unauthorized');
+}
+const fixture_path = 'src/fixtures/changelog_example.md';
+// TODO ideally this is just a ts file, but there's a problem where building outputs a `.d.ts` file
+// when importing from src/fixtures (fix in SvelteKit/Vite/tsconfig?) and I want to keep it in src/fixtures
+const changelog_cache_fixture = new Map(JSON.parse(await readFile('src/fixtures/changelog_cache.json', 'utf8')));
+test('update_changelog', async () => {
+    const original = await readFile(fixture_path, 'utf8');
+    const result = await update_changelog('ryanatkn', 'gro', fixture_path, token, log, changelog_cache_fixture);
+    const updated = await readFile(fixture_path, 'utf8');
+    await writeFile(fixture_path, original, 'utf8');
+    assert.ok(result);
+    assert.is(updated, `# @ryanatkn/gro
+
+## 0.6.0
+
+### Minor Changes
+
+- duplicate 1 ([#429](https://github.com/ryanatkn/gro/pull/429))
+- duplicate 2 ([#429](https://github.com/ryanatkn/gro/pull/429))
+- abc ([#437](https://github.com/ryanatkn/gro/pull/437))
+
+  - 123
+  - 123
+  - 123
+
+### Patch Changes
+
+- abc ([5e94cd4](https://github.com/ryanatkn/gro/commit/5e94cd4))
+
+## 0.5.2
+
+### Patch Changes
+
+- abc ([e345eaa](https://github.com/ryanatkn/gro/commit/e345eaa))
+
+## 0.5.1
+
+### Patch Changes
+
+- abc ([094279d](https://github.com/ryanatkn/gro/commit/094279d))
+
+## 0.5.0
+
+### Minor Changes
+
+- abc ([f6133f7](https://github.com/ryanatkn/gro/commit/f6133f7))
+
+## 0.4.3
+
+### Patch Changes
+
+- abc ([54b65ec](https://github.com/ryanatkn/gro/commit/54b65ec))
+
+## 0.4.2
+
+### Patch Changes
+
+- abc ([80365d0](https://github.com/ryanatkn/gro/commit/80365d0))
+
+## 0.4.1
+
+### Patch Changes
+
+- abc ([3d84dfd](https://github.com/ryanatkn/gro/commit/3d84dfd))
+- abc ([fc64b77](https://github.com/ryanatkn/gro/commit/fc64b77))
+
+## 0.4.0
+
+### Minor Changes
+
+- abc ([#434](https://github.com/ryanatkn/gro/pull/434))
+  - 123
+  - 123
+
+### Patch Changes
+
+- abc ([#434](https://github.com/ryanatkn/gro/pull/434))
+
+## 0.3.1
+
+- e
+
+## 0.3.0
+
+- b2
+- c2
+- d2
+
+## 0.2.0
+
+- a2
+
+## 0.1.2
+
+- e
+
+## 0.1.1
+
+- b
+- c
+- d
+
+## 0.1.0
+
+- a
+`);
+});
+test.run();

package/dist/changeset.task.d.ts

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import { type Task } from './task.js';
+export declare const Changeset_Bump: z.ZodEnum<["patch", "minor", "major"]>;
+export type Changeset_Bump = z.infer<typeof Changeset_Bump>;
+export declare const Args: z.ZodObject<{
+    /**
+     * The optional rest args get joined with a space to form the `message`.
+     */
+    _: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    minor: z.ZodDefault<z.ZodBoolean>;
+    major: z.ZodDefault<z.ZodBoolean>;
+    dir: z.ZodDefault<z.ZodString>;
+    access: z.ZodOptional<z.ZodEnum<["restricted", "public"]>>;
+    changelog: z.ZodDefault<z.ZodString>;
+    install: z.ZodDefault<z.ZodBoolean>;
+    'no-install': z.ZodDefault<z.ZodBoolean>;
+    origin: z.ZodDefault<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    _: string[];
+    dir: string;
+    install: boolean;
+    origin: string;
+    minor: boolean;
+    major: boolean;
+    changelog: string;
+    'no-install': boolean;
+    access?: "public" | "restricted" | undefined;
+}, {
+    _?: string[] | undefined;
+    minor?: boolean | undefined;
+    major?: boolean | undefined;
+    dir?: string | undefined;
+    access?: "public" | "restricted" | undefined;
+    changelog?: string | undefined;
+    install?: boolean | undefined;
+    'no-install'?: boolean | undefined;
+    origin?: string | undefined;
+}>;
+export type Args = z.infer<typeof Args>;
+/**
+ * Calls the `changeset` CLI with some simple automations.
+ * This API is designed for convenient manual usage, not clarity or normality.
+ *
+ * Usage:
+ * - gro changeset some commit message
+ * - gro changeset some commit message --minor
+ * - gro changeset "some commit message" --minor
+ */
+export declare const task: Task<Args>;

package/dist/changeset.task.js

@@ -0,0 +1,141 @@
+import { z } from 'zod';
+import { spawn } from '@ryanatkn/belt/process.js';
+import { red, blue } from 'kleur/colors';
+import { readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { readdir } from 'node:fs/promises';
+import { Task_Error } from './task.js';
+import { exists } from './fs.js';
+import { load_package_json } from './package_json.js';
+import { find_cli, spawn_cli } from './cli.js';
+import { Git_Origin, git_push_to_create } from './git.js';
+const RESTRICTED_ACCESS = 'restricted';
+const PUBLIC_ACCESS = 'public';
+const CHANGESET_DIR = '.changeset';
+export const Changeset_Bump = z.enum(['patch', 'minor', 'major']);
+export const Args = z
+    .object({
+    /**
+     * The optional rest args get joined with a space to form the `message`.
+     */
+    _: z.array(z.string(), { description: 'the message for the changeset and commit' }).default([]),
+    minor: z.boolean({ description: 'bump the minor version' }).default(false),
+    major: z.boolean({ description: 'bump the major version' }).default(false),
+    dir: z.string({ description: 'changeset dir' }).default(CHANGESET_DIR),
+    access: z
+        .enum([RESTRICTED_ACCESS, PUBLIC_ACCESS], {
+        description: `changeset 'access' config value, the default depends on package.json#private`,
+    })
+        .optional(),
+    changelog: z
+        .string({ description: 'changeset "changelog" config value' })
+        .default('@changesets/changelog-git'),
+    install: z.boolean({ description: 'dual of no-install' }).default(true),
+    'no-install': z
+        .boolean({ description: 'opt out of npm installing the changelog package' })
+        .default(false),
+    origin: Git_Origin.describe('git origin to deploy to').default('origin'),
+})
+    .strict();
+/**
+ * Calls the `changeset` CLI with some simple automations.
+ * This API is designed for convenient manual usage, not clarity or normality.
+ *
+ * Usage:
+ * - gro changeset some commit message
+ * - gro changeset some commit message --minor
+ * - gro changeset "some commit message" --minor
+ */
+export const task = {
+    summary: 'call changeset with gro patterns',
+    Args,
+    run: async (ctx) => {
+        const { invoke_task, args: { _, minor, major, dir, access: access_arg, changelog, install, origin }, log, } = ctx;
+        const message = _.join(' ');
+        if (!message && (minor || major))
+            throw new Task_Error('cannot bump version without a message');
+        if (minor && major)
+            throw new Task_Error('cannot bump both minor and major');
+        const bump = minor ? 'minor' : major ? 'major' : 'patch';
+        if (!(await find_cli('changeset'))) {
+            throw new Task_Error('changeset command not found: install @changesets/cli locally or globally');
+        }
+        const path = join(dir, 'config.json');
+        const inited = await exists(path);
+        const package_json = await load_package_json();
+        if (!inited) {
+            await spawn_cli('changeset', ['init']);
+            const access = access_arg ?? package_json.private ? RESTRICTED_ACCESS : PUBLIC_ACCESS;
+            const access_color = access === RESTRICTED_ACCESS ? blue : red;
+            log.info('initing changeset with ' + access_color(access) + ' access');
+            if (access !== RESTRICTED_ACCESS) {
+                await update_changeset_config(path, (config) => {
+                    const updated = { ...config };
+                    updated.access = access;
+                    updated.changelog = changelog;
+                    return updated;
+                });
+            }
+            await spawn('git', ['add', dir]);
+            if (install) {
+                await spawn('npm', ['i', '-D', changelog]);
+            }
+        }
+        await invoke_task('sync'); // after the `npm i` above, and in all cases
+        if (message) {
+            // TODO see the helper below, simplify this to CLI flags when support is added to Changesets
+            const changeset_adder = await create_changeset_adder(package_json.name, dir, message, bump);
+            await spawn_cli('changeset', ['add', '--empty']);
+            await changeset_adder();
+            await spawn('git', ['commit', '-m', message]);
+            await git_push_to_create(origin);
+        }
+        else {
+            await spawn_cli('changeset');
+            await spawn('git', ['add', dir]);
+        }
+    },
+};
+/**
+ * TODO ideally this wouldn't exist and we'd use CLI flags, but they doesn't exist yet
+ * @see https://github.com/changesets/changesets/pull/1121
+ */
+const create_changeset_adder = async (repo_name, dir, message, bump) => {
+    const filenames_before = await readdir(dir);
+    return async () => {
+        const filenames_after = await readdir(dir);
+        const filenames_added = filenames_after.filter((p) => !filenames_before.includes(p));
+        if (!filenames_added.length) {
+            throw Error('expected to find a new changeset file');
+        }
+        if (filenames_added.length !== 1) {
+            throw Error('expected to find exactly one new changeset file');
+        }
+        const path = join(dir, filenames_added[0]);
+        const contents = create_new_changeset(repo_name, message, bump);
+        await writeFile(path, contents, 'utf8');
+        await spawn('git', ['add', path]);
+    };
+};
+const create_new_changeset = (repo_name, message, bump) => `---
+"${repo_name}": ${bump}
+---
+
+${message}
+`;
+// TODO refactor all of this with zod and package_json helpers - util file helper? JSON parse pluggable
+const update_changeset_config = async (path, cb) => {
+    const config_contents = await load_changeset_config_contents(path);
+    const config = parse_changeset_config(config_contents);
+    const updated = await cb(config);
+    const serialized = serialize_changeset_config(updated);
+    if (serialized === config_contents) {
+        return false;
+    }
+    await write_changeset_config(path, serialized);
+    return true;
+};
+const load_changeset_config_contents = (path) => readFile(path, 'utf8');
+const write_changeset_config = (path, serialized) => writeFile(path, serialized);
+const serialize_changeset_config = (config) => JSON.stringify(config, null, '\t') + '\n';
+const parse_changeset_config = (contents) => JSON.parse(contents);

package/dist/check.task.d.ts

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+import { type Task } from './task.js';
+export declare const Args: z.ZodObject<{
+    typecheck: z.ZodDefault<z.ZodBoolean>;
+    'no-typecheck': z.ZodDefault<z.ZodBoolean>;
+    test: z.ZodDefault<z.ZodBoolean>;
+    'no-test': z.ZodDefault<z.ZodBoolean>;
+    gen: z.ZodDefault<z.ZodBoolean>;
+    'no-gen': z.ZodDefault<z.ZodBoolean>;
+    format: z.ZodDefault<z.ZodBoolean>;
+    'no-format': z.ZodDefault<z.ZodBoolean>;
+    package_json: z.ZodDefault<z.ZodBoolean>;
+    'no-package_json': z.ZodDefault<z.ZodBoolean>;
+    lint: z.ZodDefault<z.ZodBoolean>;
+    'no-lint': z.ZodDefault<z.ZodBoolean>;
+    workspace: z.ZodDefault<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    package_json: boolean;
+    format: boolean;
+    typecheck: boolean;
+    'no-typecheck': boolean;
+    test: boolean;
+    'no-test': boolean;
+    gen: boolean;
+    'no-gen': boolean;
+    'no-format': boolean;
+    'no-package_json': boolean;
+    lint: boolean;
+    'no-lint': boolean;
+    workspace: boolean;
+}, {
+    typecheck?: boolean | undefined;
+    'no-typecheck'?: boolean | undefined;
+    test?: boolean | undefined;
+    'no-test'?: boolean | undefined;
+    gen?: boolean | undefined;
+    'no-gen'?: boolean | undefined;
+    format?: boolean | undefined;
+    'no-format'?: boolean | undefined;
+    package_json?: boolean | undefined;
+    'no-package_json'?: boolean | undefined;
+    lint?: boolean | undefined;
+    'no-lint'?: boolean | undefined;
+    workspace?: boolean | undefined;
+}>;
+export type Args = z.infer<typeof Args>;
+export declare const task: Task<Args>;

package/dist/check.task.js

@@ -0,0 +1,77 @@
+import { z } from 'zod';
+import { spawn } from '@ryanatkn/belt/process.js';
+import { red } from 'kleur/colors';
+import { Task_Error } from './task.js';
+import { git_check_clean_workspace } from './git.js';
+import { sync_package_json } from './package_json.js';
+export const Args = z
+    .object({
+    typecheck: z.boolean({ description: 'dual of no-typecheck' }).default(true),
+    'no-typecheck': z.boolean({ description: 'opt out of typechecking' }).default(false),
+    test: z.boolean({ description: 'dual of no-test' }).default(true),
+    'no-test': z.boolean({ description: 'opt out of running tests' }).default(false),
+    gen: z.boolean({ description: 'dual of no-gen' }).default(true),
+    'no-gen': z.boolean({ description: 'opt out of gen check' }).default(false),
+    format: z.boolean({ description: 'dual of no-format' }).default(true),
+    'no-format': z.boolean({ description: 'opt out of format check' }).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 check' }).default(false),
+    lint: z.boolean({ description: 'dual of no-lint' }).default(true),
+    'no-lint': z.boolean({ description: 'opt out of linting' }).default(false),
+    workspace: z
+        .boolean({ description: 'ensure a clean git workspace, useful for CI' })
+        .default(false),
+})
+    .strict();
+export const task = {
+    summary: 'check that everything is ready to commit',
+    Args,
+    run: async ({ args, invoke_task, log, config }) => {
+        const { typecheck, test, gen, format, package_json, lint, workspace } = args;
+        // When checking the workspace, which was added for CI,
+        // don't sync, because the check will fail with misleading errors.
+        // For example it would cause the gen check to be a false negative,
+        // and then the workspace check would fail with the new files.
+        const sync = !workspace;
+        if (sync) {
+            await invoke_task('sync');
+        }
+        if (typecheck) {
+            await invoke_task('typecheck');
+        }
+        if (test) {
+            await invoke_task('test');
+        }
+        if (gen) {
+            await invoke_task('gen', { check: true });
+        }
+        if (package_json && config.map_package_json) {
+            const { changed } = await sync_package_json(config.map_package_json, log, true);
+            if (changed) {
+                throw new Task_Error('package.json is out of date, run `gro sync` to update it');
+            }
+            else {
+                log.info('check passed for package.json');
+            }
+        }
+        if (format) {
+            await invoke_task('format', { check: true });
+        }
+        // Run the linter last to surface every other kind of problem first.
+        // It's not the ideal order when the linter would catch errors that cause failing tests,
+        // but it's better for most usage.
+        if (lint) {
+            await invoke_task('lint');
+        }
+        if (workspace) {
+            const error_message = await git_check_clean_workspace();
+            if (error_message) {
+                log.error(red('git status'));
+                await spawn('git', ['status']);
+                throw new Task_Error('failed check for git_check_clean_workspace:' +
+                    error_message +
+                    ' - do you need to run `gro sync` or commit some files?');
+            }
+        }
+    },
+};

package/dist/clean.task.d.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import type { Task } from './task.js';
+export declare const Args: z.ZodObject<{
+    build_dev: z.ZodDefault<z.ZodBoolean>;
+    build_dist: z.ZodDefault<z.ZodBoolean>;
+    sveltekit: z.ZodDefault<z.ZodBoolean>;
+    nodemodules: z.ZodDefault<z.ZodBoolean>;
+    git: z.ZodDefault<z.ZodBoolean>;
+    git_origin: z.ZodDefault<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    build_dev: boolean;
+    build_dist: boolean;
+    sveltekit: boolean;
+    nodemodules: boolean;
+    git: boolean;
+    git_origin: string;
+}, {
+    build_dev?: boolean | undefined;
+    build_dist?: boolean | undefined;
+    sveltekit?: boolean | undefined;
+    nodemodules?: boolean | undefined;
+    git?: boolean | undefined;
+    git_origin?: string | undefined;
+}>;
+export type Args = z.infer<typeof Args>;
+export declare const task: Task<Args>;

package/dist/clean.task.js

@@ -0,0 +1,41 @@
+import { spawn } from '@ryanatkn/belt/process.js';
+import { z } from 'zod';
+import { clean_fs } from './clean_fs.js';
+export const Args = z
+    .object({
+    build_dev: z.boolean({ description: 'delete the Gro build dev directory' }).default(false),
+    build_dist: z.boolean({ description: 'delete the Gro build dist directory' }).default(false),
+    sveltekit: z
+        .boolean({ description: 'delete the SvelteKit directory and Vite cache' })
+        .default(false),
+    nodemodules: z.boolean({ description: 'delete the node_modules directory' }).default(false),
+    git: z
+        .boolean({
+        description: 'run "git remote prune" to delete local branches referencing nonexistent remote branches',
+    })
+        .default(false),
+    git_origin: z
+        .string({
+        description: 'the origin to "git remote prune"',
+    })
+        .default('origin'),
+})
+    .strict();
+export const task = {
+    summary: 'remove temporary dev and build files, and optionally prune git branches',
+    Args,
+    run: async ({ args }) => {
+        const { build_dev, build_dist, sveltekit, nodemodules, git, git_origin } = args;
+        await clean_fs({
+            build: !build_dev && !build_dist,
+            build_dev,
+            build_dist,
+            sveltekit,
+            nodemodules,
+        });
+        // lop off stale git branches
+        if (git) {
+            await spawn('git', ['remote', 'prune', git_origin]);
+        }
+    },
+};

package/dist/clean_fs.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import type { RmOptions } from 'node:fs';
+export declare const clean_fs: ({ build, build_dev, build_dist, sveltekit, nodemodules, }: {
+    build?: boolean | undefined;
+    build_dev?: boolean | undefined;
+    build_dist?: boolean | undefined;
+    sveltekit?: boolean | undefined;
+    nodemodules?: boolean | undefined;
+}, rm_options?: RmOptions) => Promise<void>;

package/dist/clean_fs.js

@@ -0,0 +1,27 @@
+import { rm, readdir } from 'node:fs/promises';
+import { NODE_MODULES_DIRNAME, paths, SVELTEKIT_DEV_DIRNAME, SVELTEKIT_BUILD_DIRNAME, SVELTEKIT_VITE_CACHE_PATH, GRO_DIST_PREFIX, SVELTEKIT_DIST_DIRNAME, } from './paths.js';
+export const clean_fs = async ({ build = false, build_dev = false, build_dist = false, sveltekit = false, nodemodules = false, }, rm_options = { force: true, recursive: true }) => {
+    const promises = [];
+    if (build) {
+        promises.push(rm(paths.build, rm_options));
+    }
+    else if (build_dev) {
+        promises.push(rm(paths.build_dev, rm_options));
+    }
+    if (build || build_dist) {
+        const paths = (await readdir('.')).filter((p) => p.startsWith(GRO_DIST_PREFIX));
+        for (const path of paths) {
+            promises.push(rm(path, rm_options));
+        }
+    }
+    if (sveltekit) {
+        promises.push(rm(SVELTEKIT_DEV_DIRNAME, rm_options));
+        promises.push(rm(SVELTEKIT_BUILD_DIRNAME, rm_options));
+        promises.push(rm(SVELTEKIT_DIST_DIRNAME, rm_options));
+        promises.push(rm(SVELTEKIT_VITE_CACHE_PATH, rm_options));
+    }
+    if (nodemodules) {
+        promises.push(rm(NODE_MODULES_DIRNAME, rm_options));
+    }
+    await Promise.all(promises);
+};

package/dist/cli.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import type { SpawnOptions } from 'node:child_process';
+import { type Spawn_Result } from '@ryanatkn/belt/process.js';
+/**
+ * Looks for the CLI `name`, first local to the cwd and then globally.
+ */
+export declare const find_cli: (name: string) => Promise<'local' | 'global' | null>;
+/**
+ * Calls the CLI `name` if available, first local to the cwd and then globally.
+ */
+export declare const spawn_cli: (name: string, args?: any[], options?: SpawnOptions | undefined) => Promise<Spawn_Result | undefined>;

package/dist/cli.js

@@ -0,0 +1,25 @@
+import { spawn, spawn_out } from '@ryanatkn/belt/process.js';
+import { join } from 'node:path';
+import { exists } from './fs.js';
+import { NODE_MODULES_DIRNAME } from './paths.js';
+/**
+ * Looks for the CLI `name`, first local to the cwd and then globally.
+ */
+export const find_cli = async (name) => {
+    if (await exists(join(NODE_MODULES_DIRNAME, `.bin/${name}`))) {
+        return 'local';
+    }
+    const { stdout } = await spawn_out('which', [name]);
+    return stdout === null ? null : 'global';
+};
+/**
+ * Calls the CLI `name` if available, first local to the cwd and then globally.
+ */
+export const spawn_cli = async (name, args = [], options) => {
+    const found = await find_cli(name);
+    if (!found)
+        return;
+    const command = found === 'local' ? 'npx' : name;
+    const final_args = found === 'local' ? [name].concat(args) : args;
+    return spawn(command, final_args, options);
+};

package/dist/commit.task.d.ts

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

package/dist/commit.task.js

@@ -0,0 +1,22 @@
+import { spawn } from '@ryanatkn/belt/process.js';
+import { z } from 'zod';
+import { git_current_branch_name } from './git.js';
+export const Args = z
+    .object({
+    _: z
+        .array(z.string(), {
+        description: 'the git commit message, the same as git commit -m or --message',
+    })
+        .default([]),
+})
+    .strict();
+export const task = {
+    summary: 'commit and push to a new branch',
+    Args,
+    run: async ({ args }) => {
+        const { _: [message], } = args;
+        const branch = await git_current_branch_name();
+        await spawn('git', ['commit', '-a', '-m', message]);
+        await spawn(`git push -u origin ${branch}`, [], { shell: true });
+    },
+};

package/dist/config.d.ts

@@ -0,0 +1,21 @@
+import type { Create_Config_Plugins } from './plugin.js';
+import type { Map_Package_Json } from './package_json.js';
+export interface Gro_Config {
+    plugins: Create_Config_Plugins;
+    /**
+     * Maps the project's `package.json` before writing it to the filesystem.
+     * The `package_json` argument may be mutated, but the return value is what's used by the caller.
+     * Returning `null` is a no-op for the caller.
+     */
+    map_package_json: Map_Package_Json | null;
+}
+export interface Create_Gro_Config {
+    (base_config: Gro_Config): Gro_Config | Promise<Gro_Config>;
+}
+export declare const create_empty_config: () => Gro_Config;
+export declare const DEFAULT_EXPORTS_EXCLUDER: RegExp;
+export interface Gro_Config_Module {
+    readonly default: Gro_Config | Create_Gro_Config;
+}
+export declare const load_config: (dir?: string) => Promise<Gro_Config>;
+export declare const validate_config_module: (config_module: any, config_path: string) => asserts config_module is Gro_Config_Module;