@ryanatkn/gro 0.112.0

package/dist/publish.task.js

@@ -0,0 +1,125 @@
+import { spawn } from '@ryanatkn/belt/process.js';
+import { z } from 'zod';
+import { green, cyan } from 'kleur/colors';
+import { Task_Error } from './task.js';
+import { load_package_json, parse_repo_url } from './package_json.js';
+import { find_cli, spawn_cli } from './cli.js';
+import { exists } from './fs.js';
+import { is_this_project_gro } from './paths.js';
+import { has_sveltekit_library } from './gro_plugin_sveltekit_library.js';
+import { update_changelog } from './changelog.js';
+import { load_from_env } from './env.js';
+// publish.task.ts
+// - usage: `gro publish patch`
+// - forwards args to `npm version`: https://docs.npmjs.com/v6/commands/npm-version
+// - runs the production build
+// - publishes to npm from the `main` branch, configurable with `--branch`
+// - syncs commits and tags to the configured main branch
+export const Args = z
+    .object({
+    branch: z.string({ description: 'branch to publish from' }).default('main'),
+    changelog: z
+        .string({ description: 'file name and path of the changelog' })
+        .default('CHANGELOG.md'),
+    preserve_changelog: z
+        .boolean({
+        description: 'opt out of linkifying and formatting the changelog from @changesets/changelog-git',
+    })
+        .default(false),
+    dry: z
+        .boolean({ description: 'build and prepare to publish without actually publishing' })
+        .default(false),
+    check: z.boolean({ description: 'dual of no-check' }).default(true),
+    'no-check': z
+        .boolean({ description: 'opt out of npm checking before publishing' })
+        .default(false),
+    install: z.boolean({ description: 'dual of no-install' }).default(true),
+    'no-install': z
+        .boolean({ description: 'opt out of npm installing before building' })
+        .default(false),
+})
+    .strict();
+export const task = {
+    summary: 'bump version, publish to npm, and git push',
+    Args,
+    run: async ({ args, log, invoke_task }) => {
+        const { branch, changelog, preserve_changelog, dry, check, install } = args;
+        if (dry) {
+            log.info(green('dry run!'));
+        }
+        if (!(await has_sveltekit_library())) {
+            throw new Task_Error('gro publish failed to detect a library, run `npm i -D @sveltejs/package` to enable it');
+        }
+        // TODO hacky, ensures Gro bootstraps itself
+        if (is_this_project_gro) {
+            await spawn('npm', ['run', 'build']);
+        }
+        const changelog_exists = await exists(changelog);
+        if (!(await find_cli('changeset'))) {
+            throw new Task_Error('changeset command not found: install @changesets/cli locally or globally');
+        }
+        // Make sure we're on the right branch:
+        await spawn('git', ['fetch', 'origin', branch]);
+        await spawn('git', ['checkout', branch]);
+        await spawn('git', ['pull', 'origin', branch]);
+        // Check before proceeding.
+        if (check) {
+            await invoke_task('check', { workspace: true });
+        }
+        let version;
+        // Bump the version so the package.json is updated before building:
+        // TODO problem here is build may fail and put us in a bad state,
+        // but I don't see how we could do this to robustly
+        // have the new version in the build without building twice -
+        // maybe the code should catch the error and revert the version and delete the tag?
+        if (dry) {
+            log.info('dry run, skipping changeset version');
+        }
+        else {
+            const package_json_before = await load_package_json();
+            if (typeof package_json_before.version !== 'string') {
+                throw new Task_Error('failed to find package.json version');
+            }
+            const parsed_repo_url = parse_repo_url(package_json_before);
+            if (!parsed_repo_url) {
+                throw new Task_Error('package.json `repository` must contain a repo url (and GitHub only for now, sorry),' +
+                    ' like `git+https://github.com/ryanatkn/gro.git` or `https://github.com/ryanatkn/gro`' +
+                    ' or an object with the `url` key');
+            }
+            // This is the first line that alters the repo.
+            const npmVersionResult = await spawn_cli('changeset', ['version']);
+            if (!npmVersionResult?.ok) {
+                throw Error('npm version failed: no commits were made: see the error above');
+            }
+            if (!preserve_changelog) {
+                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');
+                }
+                await update_changelog(parsed_repo_url.owner, parsed_repo_url.repo, changelog, token, log);
+            }
+            const package_json_after = await load_package_json();
+            version = package_json_after.version;
+            if (package_json_before.version === version) {
+                throw new Task_Error('changeset version failed: are there any changes?');
+            }
+        }
+        // Build to create the final artifacts:
+        await invoke_task('build', { install });
+        if (dry) {
+            log.info('publishing branch ' + branch);
+            log.info(green('dry run complete!'));
+            return;
+        }
+        const npm_publish_result = await spawn_cli('changeset', ['publish']);
+        if (!npm_publish_result?.ok) {
+            throw new Task_Error('changeset publish failed - revert the version tag or run it again manually');
+        }
+        if (!changelog_exists && (await exists(changelog))) {
+            await spawn('git', ['add', changelog]);
+        }
+        await spawn('git', ['commit', '-a', '-m', `publish v${version}`]);
+        await spawn('git', ['push', '--follow-tags']);
+        log.info(green(`published to branch ${cyan(branch)}!`));
+    },
+};

package/dist/release.task.d.ts

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

package/dist/release.task.js

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { has_sveltekit_library } from './gro_plugin_sveltekit_library.js';
+import { has_sveltekit_app } from './gro_plugin_sveltekit_app.js';
+export const Args = z.object({}).strict();
+export const task = {
+    summary: 'publish and deploy',
+    Args,
+    run: async ({ invoke_task }) => {
+        const publish = await has_sveltekit_library();
+        if (publish) {
+            await invoke_task('publish'); // TODO use `to_forwarded_args`
+        }
+        const deploy = await has_sveltekit_app();
+        if (deploy) {
+            await invoke_task('deploy', { build: !publish }); // TODO use `to_forwarded_args`
+        }
+    },
+};

package/dist/resolve_node_specifier.d.ts

@@ -0,0 +1,8 @@
+import { Package_Json } from './package_json.js';
+import { Source_Id } from './paths.js';
+export declare const resolve_node_specifier: (specifier: string, dir?: string, parent_url?: string, cache?: Record<string, Package_Json>, exports_key?: string) => Promise<Source_Id>;
+export interface Parsed_Node_Specifier {
+    name: string;
+    path: string;
+}
+export declare const parse_node_specifier: (specifier: string) => Parsed_Node_Specifier;

package/dist/resolve_node_specifier.js

@@ -0,0 +1,39 @@
+import { join } from 'node:path';
+import { Package_Json, load_package_json } from './package_json.js';
+import { NODE_MODULES_DIRNAME, Source_Id, paths } from './paths.js';
+export const resolve_node_specifier = async (specifier, dir = paths.root, parent_url, cache, exports_key = specifier.endsWith('.svelte') ? 'svelte' : 'default') => {
+    const parsed = parse_node_specifier(specifier);
+    const subpath = './' + parsed.path;
+    const package_dir = join(dir, NODE_MODULES_DIRNAME, parsed.name);
+    const package_json = await load_package_json(package_dir, cache);
+    const exported = package_json.exports?.[subpath];
+    if (!exported) {
+        // same error message as Node
+        throw Error(`[ERR_PACKAGE_PATH_NOT_EXPORTED]: Package subpath '${subpath}' is not defined by "exports" in ${package_dir}/package.json` +
+            (parent_url ? ` imported from ${parent_url}` : ''));
+    }
+    const source_id = join(package_dir, exported[exports_key]);
+    return source_id;
+};
+export const parse_node_specifier = (specifier) => {
+    let idx;
+    if (specifier[0] === '@') {
+        // get the index of the second `/`
+        let count = 0;
+        for (let i = 0; i < specifier.length; i++) {
+            if (specifier[i] === '/')
+                count++;
+            if (count === 2) {
+                idx = i;
+                break;
+            }
+        }
+    }
+    else {
+        idx = specifier.indexOf('/');
+    }
+    return {
+        name: specifier.substring(0, idx),
+        path: specifier.substring(idx + 1),
+    };
+};

package/dist/resolve_node_specifier.test.d.ts

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

package/dist/resolve_node_specifier.test.js

@@ -0,0 +1,21 @@
+import { test } from 'uvu';
+import * as assert from 'uvu/assert';
+import { resolve_node_specifier } from './resolve_node_specifier.js';
+import { paths } from './paths.js';
+test('resolves a JS specifier', async () => {
+    assert.is(await resolve_node_specifier('@fuz.dev/fuz_library/tome.js'), paths.root + 'node_modules/@fuz.dev/fuz_library/dist/tome.js');
+});
+test('resolves a Svelte specifier', async () => {
+    assert.is(await resolve_node_specifier('@fuz.dev/fuz_library/Library.svelte'), paths.root + 'node_modules/@fuz.dev/fuz_library/dist/Library.svelte');
+});
+test('throws for a specifier that does not exist', async () => {
+    let err;
+    try {
+        await resolve_node_specifier('@fuz.dev/fuz_library/this_does_not_exist');
+    }
+    catch (_err) {
+        err = _err;
+    }
+    assert.ok(err);
+});
+test.run();

package/dist/resolve_specifier.d.ts

@@ -0,0 +1,15 @@
+export interface Resolved_Specifier {
+    specifier: string;
+    source_id: string;
+    namespace: undefined | 'sveltekit_local_imports_ts' | 'sveltekit_local_imports_js';
+}
+/**
+ * Maps a `path` import specifier relative to the `importer`,
+ * and infer the correct extension following Vite conventions.
+ * If no `.js` file is found for the `path` on the filesystem, it assumes `.ts`.
+ * @param path
+ * @param dir - if defined, enables relative importers like from esbuild plugins
+ * @param passthrough_extensions - used to support specifiers that have no file extention, which Vite supports, so we do our best effort
+ * @returns
+ */
+export declare const resolve_specifier: (path: string, dir: string) => Promise<Resolved_Specifier>;

package/dist/resolve_specifier.js

@@ -0,0 +1,51 @@
+import { extname, join, relative } from 'node:path';
+import { replace_extension } from './paths.js';
+import { exists } from './fs.js';
+/**
+ * Maps a `path` import specifier relative to the `importer`,
+ * and infer the correct extension following Vite conventions.
+ * If no `.js` file is found for the `path` on the filesystem, it assumes `.ts`.
+ * @param path
+ * @param dir - if defined, enables relative importers like from esbuild plugins
+ * @param passthrough_extensions - used to support specifiers that have no file extention, which Vite supports, so we do our best effort
+ * @returns
+ */
+export const resolve_specifier = async (path, dir) => {
+    const path_id = path[0] === '/' ? path : join(dir, path);
+    let mapped_path;
+    let source_id;
+    let namespace;
+    const ext = extname(path_id);
+    const is_js = ext === '.js';
+    const is_ts = ext === '.ts';
+    if (!is_js && !is_ts && (await exists(path_id))) {
+        // unrecognized extension and the file exists
+        mapped_path = path_id;
+        source_id = path_id;
+    }
+    else if (is_ts) {
+        // explicitly ts
+        mapped_path = replace_extension(path_id, '.js');
+        source_id = path_id;
+        namespace = 'sveltekit_local_imports_ts';
+    }
+    else {
+        // extensionless, or js that points to ts, or just js
+        const js_id = is_js ? path_id : path_id + '.js';
+        const ts_id = is_js ? replace_extension(path_id, '.ts') : path_id + '.ts';
+        if (!(await exists(ts_id)) && (await exists(js_id))) {
+            mapped_path = js_id;
+            source_id = js_id;
+            namespace = 'sveltekit_local_imports_js';
+        }
+        else {
+            mapped_path = js_id;
+            source_id = ts_id;
+            namespace = 'sveltekit_local_imports_ts';
+        }
+    }
+    let specifier = relative(dir, mapped_path);
+    if (specifier[0] !== '.')
+        specifier = './' + specifier;
+    return { specifier, source_id, namespace };
+};

package/dist/resolve_specifier.test.d.ts

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

package/dist/resolve_specifier.test.js

@@ -0,0 +1,66 @@
+import { test } from 'uvu';
+import * as assert from 'uvu/assert';
+import { join } from 'node:path';
+import { resolve_specifier } from './resolve_specifier.js';
+import { paths } from './paths.js';
+const dir = paths.source + 'fixtures/';
+test('resolves a specifier to a file that exists with an unknown file extension', async () => {
+    assert.equal(await resolve_specifier(join(dir, 'test_file.other.ext'), dir), {
+        specifier: './test_file.other.ext',
+        source_id: join(dir, 'test_file.other.ext'),
+        namespace: undefined,
+    });
+});
+test('resolves a ts specifier', async () => {
+    assert.equal(await resolve_specifier(join(dir, 'test_ts.ts'), dir), {
+        specifier: './test_ts.js',
+        source_id: join(dir, 'test_ts.ts'),
+        namespace: 'sveltekit_local_imports_ts',
+    });
+});
+test('resolves relative ts specifiers', async () => {
+    assert.equal(await resolve_specifier('./test_ts.ts', dir), {
+        specifier: './test_ts.js',
+        source_id: join(dir, 'test_ts.ts'),
+        namespace: 'sveltekit_local_imports_ts',
+    });
+    assert.equal(await resolve_specifier('./a/b/test_ts.ts', dir), {
+        specifier: './a/b/test_ts.js',
+        source_id: join(dir, 'a/b/test_ts.ts'),
+        namespace: 'sveltekit_local_imports_ts',
+    });
+    assert.equal(await resolve_specifier('../../test_ts.ts', dir), {
+        specifier: '../../test_ts.js',
+        source_id: join(dir, '../../test_ts.ts'),
+        namespace: 'sveltekit_local_imports_ts',
+    });
+});
+test('resolves an extensionless specifier', async () => {
+    assert.equal(await resolve_specifier(join(dir, 'test_ts'), dir), {
+        specifier: './test_ts.js',
+        source_id: join(dir, 'test_ts.ts'),
+        namespace: 'sveltekit_local_imports_ts',
+    });
+});
+test('resolves a js specifier', async () => {
+    assert.equal(await resolve_specifier(join(dir, 'test_js.js'), dir), {
+        specifier: './test_js.js',
+        source_id: join(dir, 'test_js.js'),
+        namespace: 'sveltekit_local_imports_js',
+    });
+});
+test('resolves a js specifier as ts for a file that does not exist', async () => {
+    assert.equal(await resolve_specifier(join(dir, 'test_missing.js'), dir), {
+        specifier: './test_missing.js',
+        source_id: join(dir, 'test_missing.ts'),
+        namespace: 'sveltekit_local_imports_ts',
+    });
+});
+test('resolves an extensionless specifier for a file that does not exist', async () => {
+    assert.equal(await resolve_specifier(join(dir, 'test_missing'), dir), {
+        specifier: './test_missing.js',
+        source_id: join(dir, 'test_missing.ts'),
+        namespace: 'sveltekit_local_imports_ts',
+    });
+});
+test.run();

package/dist/run.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/run.task.js

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { green, cyan } from 'kleur/colors';
+import { Task_Error } from './task.js';
+import { exists } from './fs.js';
+import { resolve_gro_module_path, spawn_with_loader } from './gro_helpers.js';
+export const Args = z
+    .object({
+    _: z
+        .array(z.string(), { description: 'the file path to run and other node CLI args' })
+        .default([]),
+})
+    .strict();
+export const task = {
+    summary: 'execute a file with the loader, like `node` but works for TypeScript',
+    Args,
+    run: async ({ args, log }) => {
+        const { _: [path, ...argv], } = args;
+        if (!path) {
+            log.info(green('\n\nUsage: ') + cyan('gro run path/to/file.ts [...node_args]\n'));
+            return;
+        }
+        if (!(await exists(path))) {
+            throw new Task_Error('cannot find file to run at path: ' + path);
+        }
+        const loader_path = await resolve_gro_module_path('loader.js');
+        const spawned = await spawn_with_loader(loader_path, path, argv);
+        if (!spawned.ok) {
+            throw new Task_Error(`\`gro run ${path}\` failed with exit code ${spawned.code}`);
+        }
+    },
+};

package/dist/run_gen.d.ts

@@ -0,0 +1,6 @@
+import { type Gen_Module_Meta } from './gen_module.js';
+import { type Gen_Results } from './gen.js';
+import type { format_file as base_format_file } from './format_file.js';
+export declare const GEN_NO_PROD_MESSAGE = "gen runs only during development";
+export declare const run_gen: (gen_modules: Gen_Module_Meta[], log: Logger, timings: Timings, format_file?: typeof base_format_file) => Promise<Gen_Results>;
+export declare const to_gen_import_path: (id: string) => string;

package/dist/run_gen.js

@@ -0,0 +1,74 @@
+import { red } from 'kleur/colors';
+import { print_error } from '@ryanatkn/belt/print.js';
+import { Unreachable_Error } from '@ryanatkn/belt/error.js';
+import { strip_end } from '@ryanatkn/belt/string.js';
+import { GEN_SCHEMA_PATH_SUFFIX } from './gen_module.js';
+import { to_gen_result, } from './gen.js';
+import { print_path, source_id_to_base_path } from './paths.js';
+export const GEN_NO_PROD_MESSAGE = 'gen runs only during development';
+export const run_gen = async (gen_modules, log, timings, format_file) => {
+    let input_count = 0;
+    let output_count = 0;
+    const timing_for_run_gen = timings.start('run_gen');
+    const results = await Promise.all(gen_modules.map(async (module_meta) => {
+        input_count++;
+        const { id } = module_meta;
+        const timing_for_module = timings.start(id);
+        // Perform code generation by calling `gen` on the module.
+        const gen_ctx = { origin_id: id, log };
+        let raw_gen_result;
+        try {
+            switch (module_meta.type) {
+                case 'basic': {
+                    raw_gen_result = await module_meta.mod.gen(gen_ctx);
+                    break;
+                }
+                default: {
+                    throw new Unreachable_Error(module_meta.type);
+                }
+            }
+        }
+        catch (err) {
+            return {
+                ok: false,
+                id,
+                error: err,
+                reason: red(`Error generating ${print_path(id)}`),
+                elapsed: timing_for_module(),
+            };
+        }
+        // Convert the module's return value to a normalized form.
+        const gen_result = to_gen_result(id, raw_gen_result);
+        // Format the files if needed.
+        const files = format_file
+            ? await Promise.all(gen_result.files.map(async (file) => {
+                if (!file.format)
+                    return file;
+                try {
+                    return { ...file, content: await format_file(file.content, { filepath: file.id }) };
+                }
+                catch (err) {
+                    log.error(red(`Error formatting ${print_path(file.id)} via ${print_path(id)}`), print_error(err));
+                    return file;
+                }
+            }))
+            : gen_result.files;
+        output_count += files.length;
+        return {
+            ok: true,
+            id,
+            files,
+            elapsed: timing_for_module(),
+        };
+    }));
+    return {
+        results,
+        successes: results.filter((r) => r.ok),
+        failures: results.filter((r) => !r.ok),
+        input_count,
+        output_count,
+        elapsed: timing_for_run_gen(),
+    };
+};
+// TODO configurable
+export const to_gen_import_path = (id) => '$' + strip_end(source_id_to_base_path(id), GEN_SCHEMA_PATH_SUFFIX);

package/dist/run_gen.test.d.ts

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