@ryanatkn/gro 0.124.0 → 0.125.0

package/dist/package_json.js

@@ -1,8 +1,9 @@
 import { z } from 'zod';
 import { join } from 'node:path';
 import { readFile, writeFile } from 'node:fs/promises';
-import { plural } from '@ryanatkn/belt/string.js';
+import { count_graphemes, plural } from '@ryanatkn/belt/string.js';
 import { strip_end } from '@ryanatkn/belt/string.js';
+import { red } from 'kleur/colors';
 import { paths, gro_paths, IS_THIS_GRO, replace_extension } from './paths.js';
 import { SVELTEKIT_DIST_DIRNAME } from './path_constants.js';
 import { search_fs } from './search_fs.js';
@@ -51,25 +52,33 @@ export const Package_Json_Exports = z.record(z.union([z.string(), z.record(z.str
 /**
  * @see https://docs.npmjs.com/cli/v10/configuring-npm/package-json
  */
-export const Package_Json = z.intersection(z.record(z.unknown()), z
+export const Package_Json = z
     .object({
     // according to the npm docs, `name` and `version` are the only required properties
     name: z.string(),
     version: z.string(),
-    // Gro extensions
+    private: z.boolean({ description: 'disallow npm publish' }).optional(),
     public: z
         .boolean({
         description: 'a Gro extension that enables publishing `.well-known/package.json` and `.well-known/src`',
     })
         .optional(),
-    icon: z.string({ description: 'a Gro extension' }).optional(), // TODO maybe base64 favicon?
-    private: z.boolean({ description: 'disallow npm publish' }).optional(),
     description: z.string().optional(),
-    motto: z.string().optional(),
+    motto: z
+        .string({ description: "a Gro extension that's a short phrase that represents this project" })
+        .optional(),
+    // TODO icon/favicon/logo that can point to a URL as an alternative to `<link rel="icon"`?
+    glyph: z
+        .string({
+        description: "a Gro extension that's a single unicode character that represents this project",
+    })
+        .refine((v) => count_graphemes(v) === 1, 'must be a single unicode character')
+        .optional(),
     license: z.string().optional(),
+    scripts: z.record(z.string()).optional(),
     homepage: Url.optional(),
-    repository: z.union([z.string(), Url, Package_Json_Repository]).optional(),
     author: z.union([z.string(), Package_Json_Author.optional()]),
+    repository: z.union([z.string(), Url, Package_Json_Repository]).optional(),
     contributors: z.array(z.union([z.string(), Package_Json_Author])).optional(),
     bugs: z
         .union([z.string(), z.object({ url: Url.optional(), email: Email.optional() }).passthrough()])
@@ -78,20 +87,20 @@ export const Package_Json = z.intersection(z.record(z.unknown()), z
         .union([Url, Package_Json_Funding, z.array(z.union([Url, Package_Json_Funding]))])
         .optional(),
     keywords: z.array(z.string()).optional(),
-    scripts: z.record(z.string()).optional(),
-    bin: z.record(z.string()).optional(),
-    files: z.array(z.string()).optional(),
-    exports: Package_Json_Exports.transform(transform_empty_object_to_undefined).optional(),
+    type: z.string().optional(),
+    engines: z.record(z.string()).optional(),
+    os: z.array(z.string()).optional(),
+    cpu: z.array(z.string()).optional(),
     dependencies: z.record(z.string()).optional(),
     devDependencies: z.record(z.string()).optional(),
     peerDependencies: z.record(z.string()).optional(),
     peerDependenciesMeta: z.record(z.record(z.string())).optional(),
     optionalDependencies: z.record(z.string()).optional(),
-    engines: z.record(z.string()).optional(),
-    os: z.array(z.string()).optional(),
-    cpu: z.array(z.string()).optional(),
+    bin: z.record(z.string()).optional(),
+    files: z.array(z.string()).optional(),
+    exports: Package_Json_Exports.transform(transform_empty_object_to_undefined).optional(),
 })
-    .passthrough());
+    .passthrough();
 export const EMPTY_PACKAGE_JSON = { name: '', version: '' };
 export const load_package_json = async (dir = IS_THIS_GRO ? gro_paths.root : paths.root, cache) => {
     let package_json;
@@ -104,6 +113,7 @@ export const load_package_json = async (dir = IS_THIS_GRO ? gro_paths.root : pat
     catch (err) {
         return EMPTY_PACKAGE_JSON;
     }
+    package_json = parse_package_json(Package_Json, package_json);
     if (cache)
         cache[dir] = package_json;
     return package_json;
@@ -117,7 +127,7 @@ export const sync_package_json = async (map_package_json, log, check = false, di
             package_json.exports = exports;
         }
         const mapped = await map_package_json(package_json);
-        return mapped ? Package_Json.parse(mapped) : mapped;
+        return mapped ? parse_package_json(Package_Json, mapped) : mapped;
     }, !check);
     const exports_count = updated.changed && updated.package_json?.exports
         ? Object.keys(updated.package_json.exports).length
@@ -133,10 +143,7 @@ const load_package_json_contents = (dir) => readFile(join(dir, 'package.json'),
 export const write_package_json = async (serialized_package_json) => {
     await writeFile(join(paths.root, 'package.json'), serialized_package_json);
 };
-export const serialize_package_json = (package_json) => {
-    Package_Json.parse(package_json);
-    return JSON.stringify(package_json, null, 2) + '\n';
-};
+export const serialize_package_json = (package_json) => JSON.stringify(parse_package_json(Package_Json, package_json), null, 2) + '\n';
 /**
  * Updates package.json. Writes to the filesystem only when contents change.
  */
@@ -173,30 +180,30 @@ export const to_package_exports = (paths) => {
         else if (path.endsWith('.json.d.ts')) {
             const json_path = path.substring(0, path.length - 5);
             exports['./' + json_path] = {
-                default: IMPORT_PREFIX + json_path, // assuming a matching json file
                 types: IMPORT_PREFIX + path,
+                default: IMPORT_PREFIX + json_path, // assuming a matching json file
             };
         }
         else if (path.endsWith('.ts') && !path.endsWith('.d.ts')) {
             const js_path = replace_extension(path, '.js');
             const key = is_index(path) ? '.' : './' + js_path;
             exports[key] = {
-                default: IMPORT_PREFIX + js_path,
                 types: IMPORT_PREFIX + replace_extension(path, '.d.ts'),
+                default: IMPORT_PREFIX + js_path,
             };
         }
         else if (path.endsWith('.js')) {
             const key = is_index(path) ? '.' : './' + path;
             exports[key] = {
-                default: IMPORT_PREFIX + path,
                 types: IMPORT_PREFIX + replace_extension(path, '.d.ts'), // assuming JSDoc types
+                default: IMPORT_PREFIX + path,
             };
         }
         else if (path.endsWith('.svelte')) {
             exports['./' + path] = {
+                types: IMPORT_PREFIX + path + '.d.ts',
                 svelte: IMPORT_PREFIX + path,
                 default: IMPORT_PREFIX + path, // needed for loader imports
-                types: IMPORT_PREFIX + path + '.d.ts',
             };
         }
         else {
@@ -205,7 +212,7 @@ export const to_package_exports = (paths) => {
             };
         }
     }
-    return Package_Json_Exports.parse(exports);
+    return parse_or_throw_formatted_error('package.json#exports', Package_Json_Exports, exports);
 };
 const IMPORT_PREFIX = './' + SVELTEKIT_DIST_DIRNAME + '/';
 export const parse_repo_url = (package_json) => {
@@ -225,3 +232,23 @@ export const parse_repo_url = (package_json) => {
     const [, owner, repo] = parsed_repo_url;
     return { owner, repo };
 };
+/**
+ * Parses a `Package_Json` object but preserves the order of the original keys.
+ */
+const parse_package_json = (schema, value) => {
+    const parsed = parse_or_throw_formatted_error('package.json', schema, value);
+    const keys = Object.keys(value);
+    return Object.fromEntries(Object.entries(parsed).sort(([a], [b]) => keys.indexOf(a) - keys.indexOf(b)));
+};
+// TODO maybe extract to zod helpers? see also everything in `task_logging.ts`
+const parse_or_throw_formatted_error = (name, schema, value) => {
+    const parsed = schema.safeParse(value);
+    if (!parsed.success) {
+        let msg = red(`Failed to parse ${name}:\n`);
+        for (const issue of parsed.error.issues) {
+            msg += red(`\n\t"${issue.path}" ${issue.message}\n`);
+        }
+        throw Error(msg);
+    }
+    return parsed.data;
+};

package/dist/path.d.ts

@@ -1,4 +1,7 @@
 import type { Flavored } from '@ryanatkn/belt/types.js';
+/**
+ * An absolute path on the filesystem. Named "id" to be consistent with Rollup.
+ */
 export type Path_Id = Flavored<string, 'Path_Id'>;
 export interface Path_Info {
     id: Path_Id;

package/dist/publish.task.d.ts

@@ -13,12 +13,14 @@ export declare const Args: z.ZodObject<{
     'no-build': z.ZodDefault<z.ZodBoolean>;
     pull: z.ZodDefault<z.ZodBoolean>;
     'no-pull': z.ZodDefault<z.ZodBoolean>;
+    changeset_cli: z.ZodDefault<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
     build: boolean;
     origin: string & z.BRAND<"Git_Origin">;
     pull: boolean;
     branch: string & z.BRAND<"Git_Branch">;
     changelog: string;
+    changeset_cli: string;
     check: boolean;
     dry: boolean;
     'no-build': boolean;
@@ -32,6 +34,7 @@ export declare const Args: z.ZodObject<{
     pull?: boolean | undefined;
     branch?: string | undefined;
     changelog?: string | undefined;
+    changeset_cli?: string | undefined;
     check?: boolean | undefined;
     dry?: boolean | undefined;
     'no-build'?: boolean | undefined;

package/dist/publish.task.js

@@ -10,6 +10,7 @@ import { has_sveltekit_library } from './sveltekit_helpers.js';
 import { update_changelog } from './changelog.js';
 import { load_from_env } from './env.js';
 import { Git_Branch, Git_Origin, git_check_clean_workspace, git_checkout, git_fetch, git_pull, } from './git.js';
+import { CHANGESET_CLI } from './changeset_helpers.js';
 // publish.task.ts
 // - usage: `gro publish patch`
 // - forwards args to `npm version`: https://docs.npmjs.com/v6/commands/npm-version
@@ -40,13 +41,14 @@ export const Args = z
     'no-build': z.boolean({ description: 'opt out of building' }).default(false),
     pull: z.boolean({ description: 'dual of no-pull' }).default(true),
     'no-pull': z.boolean({ description: 'opt out of git pull' }).default(false),
+    changeset_cli: z.string({ description: 'the changeset CLI to use' }).default(CHANGESET_CLI),
 })
     .strict();
 export const task = {
     summary: 'bump version, publish to npm, and git push',
     Args,
     run: async ({ args, log, invoke_task }) => {
-        const { branch, origin, changelog, preserve_changelog, dry, check, build, pull, optional } = args;
+        const { branch, origin, changelog, preserve_changelog, dry, check, build, pull, optional, changeset_cli, } = args;
         if (dry) {
             log.info(green('dry run!'));
         }
@@ -59,7 +61,8 @@ export const task = {
             await spawn('npm', ['run', 'build']);
         }
         const changelog_exists = existsSync(changelog);
-        if (!(await find_cli('changeset'))) {
+        const found_changeset_cli = await find_cli(changeset_cli);
+        if (!found_changeset_cli) {
             throw new Task_Error('changeset command not found, install @changesets/cli locally or globally');
         }
         // Make sure we're on the right branch:
@@ -96,7 +99,7 @@ export const task = {
                     ' or an object with the `url` key');
             }
             // This is the first line that alters the repo.
-            const npmVersionResult = await spawn_cli('changeset', ['version']);
+            const npmVersionResult = await spawn_cli(found_changeset_cli, ['version'], log);
             if (!npmVersionResult?.ok) {
                 throw Error('npm version failed: no commits were made: see the error above');
             }
@@ -116,7 +119,7 @@ export const task = {
                     return; // exit gracefully
                 }
                 else {
-                    throw new Task_Error('changeset version failed: are there any changes?');
+                    throw new Task_Error(`\`${changeset_cli} version\` failed: are there any changes?`);
                 }
             }
         }
@@ -128,9 +131,9 @@ export const task = {
             log.info(green('dry run complete!'));
             return;
         }
-        const npm_publish_result = await spawn_cli('changeset', ['publish']);
+        const npm_publish_result = await spawn_cli(found_changeset_cli, ['publish'], log);
         if (!npm_publish_result?.ok) {
-            throw new Task_Error('changeset publish failed - revert the version tag or run it again manually');
+            throw new Task_Error(`\`${changeset_cli} publish\` failed - revert the version tag or run it again manually`);
         }
         if (!changelog_exists && existsSync(changelog)) {
             await spawn('git', ['add', changelog]);

package/dist/search_fs.d.ts

@@ -3,11 +3,11 @@ export interface Search_Fs_Options {
     /**
      * One or more filter functions, any of which can short-circuit the search by returning `false`.
      */
-    filter?: Path_Filter | Path_Filter[] | null;
+    filter?: Path_Filter | Path_Filter[];
     /**
      * An array of file suffixes to include.
      */
-    file_filter?: File_Filter | File_Filter[] | null;
+    file_filter?: File_Filter | File_Filter[];
     /**
      * Pass `null` or `false` to speed things up at the cost of volatile ordering.
      */

package/dist/sveltekit_helpers.d.ts

@@ -1,17 +1,20 @@
 import type { Result } from '@ryanatkn/belt/result.js';
 import { Package_Json } from './package_json.js';
 import type { Parsed_Sveltekit_Config } from './sveltekit_config.js';
+import { type Cli } from './cli.js';
 export declare const SVELTEKIT_CLI = "svelte-kit";
+export declare const SVELTE_CHECK_CLI = "svelte-check";
 export declare const SVELTE_PACKAGE_CLI = "svelte-package";
 export declare const SVELTE_PACKAGE_DEP_NAME = "@sveltejs/package";
+export declare const VITE_CLI = "vite";
 export declare const has_sveltekit_app: () => Promise<Result<object, {
     message: string;
 }>>;
 export declare const has_sveltekit_library: (package_json?: Package_Json, sveltekit_config?: Parsed_Sveltekit_Config) => Promise<Result<object, {
     message: string;
 }>>;
-export declare const sveltekit_sync: () => Promise<void>;
+export declare const sveltekit_sync: (sveltekit_cli?: string | Cli) => Promise<void>;
 /**
  * If the SvelteKit CLI is found and its `.svelte-kit` directory is not, run `svelte-kit sync`.
  */
-export declare const sveltekit_sync_if_obviously_needed: () => Promise<void>;
+export declare const sveltekit_sync_if_obviously_needed: (sveltekit_cli?: string | Cli) => Promise<void>;

package/dist/sveltekit_helpers.js

@@ -2,11 +2,13 @@ import { existsSync } from 'node:fs';
 import { Package_Json, load_package_json } from './package_json.js';
 import { sveltekit_config_global } from './sveltekit_config_global.js';
 import { SVELTEKIT_CONFIG_FILENAME, SVELTEKIT_DEV_DIRNAME } from './path_constants.js';
-import { find_cli, spawn_cli } from './cli.js';
+import { find_cli, spawn_cli, to_cli_name } from './cli.js';
 import { Task_Error } from './task.js';
 export const SVELTEKIT_CLI = 'svelte-kit';
+export const SVELTE_CHECK_CLI = 'svelte-check';
 export const SVELTE_PACKAGE_CLI = 'svelte-package';
 export const SVELTE_PACKAGE_DEP_NAME = '@sveltejs/package';
+export const VITE_CLI = 'vite';
 export const has_sveltekit_app = async () => {
     if (!existsSync(SVELTEKIT_CONFIG_FILENAME)) {
         return { ok: false, message: `no SvelteKit config found at ${SVELTEKIT_CONFIG_FILENAME}` };
@@ -31,24 +33,25 @@ export const has_sveltekit_library = async (package_json, sveltekit_config = sve
     }
     return { ok: true };
 };
-export const sveltekit_sync = async () => {
-    if (!(await find_cli(SVELTEKIT_CLI))) {
-        throw new Task_Error(`Failed to find ${SVELTEKIT_CLI} CLI - do you need to run \`npm i\`?`);
+export const sveltekit_sync = async (sveltekit_cli = SVELTEKIT_CLI) => {
+    const result = await spawn_cli(sveltekit_cli, ['sync']);
+    if (!result) {
+        throw new Task_Error(`Failed to find SvelteKit CLI \`${to_cli_name(sveltekit_cli)}\`, do you need to run \`npm i\`?`);
     }
-    const result = await spawn_cli(SVELTEKIT_CLI, ['sync']);
-    if (!result?.ok) {
-        throw new Task_Error(`Failed ${SVELTEKIT_CLI} sync`);
+    else if (!result.ok) {
+        throw new Task_Error(`Failed ${to_cli_name(sveltekit_cli)} sync`);
     }
 };
 /**
  * If the SvelteKit CLI is found and its `.svelte-kit` directory is not, run `svelte-kit sync`.
  */
-export const sveltekit_sync_if_obviously_needed = async () => {
+export const sveltekit_sync_if_obviously_needed = async (sveltekit_cli = SVELTEKIT_CLI) => {
     if (existsSync(SVELTEKIT_DEV_DIRNAME)) {
         return;
     }
-    if (!(await find_cli(SVELTEKIT_CLI))) {
+    const found_sveltekit_cli = typeof sveltekit_cli === 'string' ? await find_cli(sveltekit_cli) : sveltekit_cli;
+    if (!found_sveltekit_cli) {
         return;
     }
-    return sveltekit_sync();
+    return sveltekit_sync(found_sveltekit_cli);
 };

package/dist/test.task.js

@@ -24,8 +24,7 @@ export const task = {
             log.warn(yellow('uvu is not installed, skipping tests'));
             return;
         }
-        const { run } = await import('uvu/run');
-        const { parse } = await import('uvu/parse');
+        const [{ run }, { parse }] = await Promise.all([import('uvu/run'), import('uvu/parse')]);
         // uvu doesn't work with esm loaders and TypeScript files,
         // so we use its `parse` and `run` APIs directly instead of its CLI.
         // To avoid surprises, we allow any number of patterns in the rest args,

package/dist/typecheck.task.d.ts

@@ -1,5 +1,14 @@
 import { z } from 'zod';
 import { type Task } from './task.js';
-export declare const Args: z.ZodObject<{}, "strict", z.ZodTypeAny, {}, {}>;
+export declare const Args: z.ZodObject<{
+    svelte_check_cli: z.ZodDefault<z.ZodString>;
+    typescript_cli: z.ZodDefault<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    svelte_check_cli: string;
+    typescript_cli: string;
+}, {
+    svelte_check_cli?: string | undefined;
+    typescript_cli?: string | undefined;
+}>;
 export type Args = z.infer<typeof Args>;
 export declare const task: Task<Args>;

package/dist/typecheck.task.js

@@ -1,38 +1,48 @@
 import { print_spawn_result } from '@ryanatkn/belt/process.js';
 import { z } from 'zod';
 import { Task_Error } from './task.js';
-import { print_command_args, serialize_args, to_forwarded_args } from './args.js';
+import { serialize_args, to_forwarded_args } from './args.js';
 import { find_cli, spawn_cli } from './cli.js';
-import { sveltekit_sync } from './sveltekit_helpers.js';
-export const Args = z.object({}).strict();
+import { SVELTE_CHECK_CLI, sveltekit_sync } from './sveltekit_helpers.js';
+export const Args = z
+    .object({
+    svelte_check_cli: z
+        .string({ description: 'the svelte-check CLI to use' })
+        .default(SVELTE_CHECK_CLI),
+    typescript_cli: z
+        .string({ description: 'the TypeScript CLI to use as a fallback to svelte-check' })
+        .default('tsc'),
+})
+    .strict();
 export const task = {
     summary: 'run tsc on the project without emitting any files',
     Args,
-    run: async ({ log }) => {
+    run: async ({ args, log }) => {
+        const { svelte_check_cli, typescript_cli } = args;
         await sveltekit_sync();
-        if (await find_cli('svelte-check')) {
-            // svelte-check
-            const serialized = serialize_args(to_forwarded_args('svelte-check'));
-            log.info(print_command_args(['svelte-check'].concat(serialized)));
-            const svelte_check_result = await spawn_cli('svelte-check', serialized);
+        // Prefer svelte-check if available.
+        const found_svelte_check_cli = await find_cli(svelte_check_cli);
+        if (found_svelte_check_cli) {
+            const serialized = serialize_args(to_forwarded_args(svelte_check_cli));
+            const svelte_check_result = await spawn_cli(found_svelte_check_cli, serialized, log);
             if (!svelte_check_result?.ok) {
                 throw new Task_Error(`Failed to typecheck. ${print_spawn_result(svelte_check_result)}`);
             }
+            return;
         }
-        else if (await find_cli('tsc')) {
-            // tsc
-            const forwarded = to_forwarded_args('tsc');
+        // Fall back to tsc.
+        const found_typescript_cli = await find_cli(typescript_cli);
+        if (found_typescript_cli) {
+            const forwarded = to_forwarded_args(typescript_cli);
             if (!forwarded.noEmit)
                 forwarded.noEmit = true;
             const serialized = serialize_args(forwarded);
-            log.info(print_command_args(['tsc'].concat(serialized)));
-            const svelte_check_result = await spawn_cli('tsc', serialized);
+            const svelte_check_result = await spawn_cli(found_typescript_cli, serialized, log);
             if (!svelte_check_result?.ok) {
                 throw new Task_Error(`Failed to typecheck. ${print_spawn_result(svelte_check_result)}`);
             }
+            return;
         }
-        else {
-            throw new Task_Error(`Failed to typecheck because neither tsc nor svelte-check was found`);
-        }
+        throw new Task_Error(`Failed to typecheck because neither \`${svelte_check_cli}\` nor \`${typescript_cli}\` was found`);
     },
 };