@ryanatkn/gro 0.112.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Ryan Atkinson <mail@ryanatkn.com> (https://ryanatkn.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,257 @@
+# gro <img src="static/favicon.png" width="32" height="32">
+
+<img src="static/favicon.png" align="right" width="192" height="192">
+
+> task runner and toolkit extending SvelteKit - [gro.ryanatkn.com](https://gro.ryanatkn.com)
+
+[`npm i -D @ryanatkn/gro`](https://www.npmjs.com/package/@ryanatkn/gro)
+
+limitations:
+
+- Gro has been actively used since 2019 but it has few users,
+  so you'll likely encounter problems and undesirable limitations --
+  please open issues!
+- [Windows won't be supported](https://github.com/ryanatkn/gro/issues/319)
+
+## about
+
+Gro is a task runner and toolkit
+extending [SvelteKit](https://github.com/sveltejs/kit),
+[Vite](https://github.com/vitejs/vite),
+and [esbuild](https://github.com/evanw/esbuild)
+for making web frontends, servers, and libraries with TypeScript.
+It includes:
+
+- [task runner](/src/lib/docs/task.md) that uses the filesystem convention `*.task.ts`
+  - lots of [common builtin tasks](/src/lib/docs/tasks.md) that users can easily override and compose
+- tools and patterns for
+  [developing](/src/lib/docs/dev.md),
+  [building](/src/lib/docs/build.md),
+  [testing](/src/lib/docs/test.md),
+  [deploying](/src/lib/docs/deploy.md),
+  and [publishing](/src/lib/docs/publish.md)
+  [SvelteKit](https://github.com/sveltejs/kit) apps, library packages, and Node servers
+  - integrated [TypeScript](https://github.com/microsoft/typescript),
+    [Svelte](https://github.com/sveltejs/svelte),
+    and [SvelteKit](https://github.com/sveltejs/kit)
+  - defers to SvelteKit and Vite for the frontend and
+    [`@sveltejs/package`](https://kit.svelte.dev/docs/packaging) for the library
+  - uses [Changesets](https://github.com/changesets/changesets) for versioning and changelogs
+  - provides a [Node loader](/src/lib/loader.ts) and
+    [esbuild plugins for the server](/src/lib/gro_plugin_server.ts)
+    - supports importing TypeScript, JSON, and SSR'd Svelte files in tests and tasks
+    - supports [SvelteKit module imports](https://kit.svelte.dev/docs/modules) for
+      `$lib`, `$env`, and `$app` in tasks, tests, Node servers,
+      and other code outside of the SvelteKit frontend,
+      so you can use SvelteKit patterns everywhere
+      (these are best-effort shims, not perfect)
+    - supports running TypeScript files directly without a task via `gro run a.ts`
+  - [configurable plugins](/src/lib/docs/plugin.md)
+    to support SvelteKit, auto-restarting Node servers, and other external build processes
+    - see the [Gro config docs](/src/lib/docs/config.md) and
+      [the default config](https://github.com/ryanatkn/gro/blob/main/src/lib/gro.config.default.ts)
+    - see [`fuz_template`](https://github.com/fuz-dev/fuz_template)
+      for a simple starter project example, and
+      [`@feltjs/felt`](https://github.com/feltjs/felt) for a more complex example with custom tasks
+- [testing](/src/lib/docs/test.md) with [`uvu`](https://github.com/lukeed/uvu)
+- codegen by convention with [`gen`](/src/lib/docs/gen.md)
+- linting with [ESLint](https://github.com/eslint/eslint)
+  (I also maintain [`@feltjs/eslint-config`](https://github.com/feltjs/eslint-config))
+- formatting with [Prettier](https://github.com/prettier/prettier)
+  (it's not always pretty but it saves time writing and reading code,
+  my time is more precious than my formatting style)
+
+## docs
+
+- developing web frontends, servers, and libraries
+  - [config](/src/lib/docs/config.md)
+  - [dev](/src/lib/docs/dev.md)
+  - [build](/src/lib/docs/build.md) for production
+  - [deploy](/src/lib/docs/deploy.md) to a branch, like for GitHub pages
+  - [publish](/src/lib/docs/publish.md) to npm
+- [`Task`](/src/lib/docs/task.md) runner
+  - builtin [tasks](/src/lib/docs/tasks.md) list
+- [testing](/src/lib/docs/test.md) with [`uvu`](https://github.com/lukeed/uvu)
+- [`gen`](/src/lib/docs/gen.md) code generation
+- [`public` package](/src/lib/docs/package_json.md#public-packages) features (nonstandard)
+- full [docs index](/src/lib/docs#readme)
+
+## install
+
+> depends on node >=20.10
+
+Typical usage installs [@ryanatkn/gro](https://www.npmjs.com/package/@ryanatkn/gro)
+as a dev dependency:
+
+```bash
+npm i -D @ryanatkn/gro
+npx gro
+```
+
+It's handy to install globally too:
+
+```bash
+npm i -g @ryanatkn/gro
+gro
+```
+
+## usage
+
+Gro has a task runner that discovers and runs TypeScript modules with the `.task.` subextension.
+Running `gro` with no args prints the tasks
+it finds in the current directory along with its builtin tasks:
+
+```bash
+gro # prints available tasks - defers to any local gro installation
+```
+
+```
+Run a task: gro [name]
+View help:  gro [name] --help
+
+17 tasks in gro:
+
+build      build the project
+changeset  call changeset with gro patterns
+check      check that everything is ready to commit
+clean      remove temporary dev and build files, and optionally prune git branches
+commit     commit and push to a new branch
+deploy     deploy to a branch
+dev        start SvelteKit and other dev plugins
+exports    write the "exports" property of package.json and copy the file to .well-known
+format     format source files
+gen        run code generation scripts
+lint       run eslint
+publish    bump version, publish to npm, and git push
+release    publish and deploy
+sync       run `gro gen`, `gro exports`, and optionally `npm i` to sync up
+test       run tests with uvu
+typecheck  run tsc on the project without emitting any files
+upgrade    upgrade deps
+```
+
+Gro matches your CLI input against its filesystem conventions.
+It tries to do the right thing, where right is helpful but not surprising,
+with some magic but not too much:
+
+```bash
+gro # print all available tasks, those matching `src/lib/**/*.task.ts` and Gro's builtins
+gro some/dir # list all tasks inside `src/lib/some/dir`
+gro some/file # run `src/lib/some/file.task.ts`
+gro some/file.task.ts # same as above
+gro a # run `src/lib/a.task.ts` if it exists, falling back to Gro's builtin
+gro a --help # print info about the "a" task; works for every task
+```
+
+Gro has a number of builtin tasks that you can run with the CLI.
+To learn more [see the task docs](/src/lib/docs/task.md)
+and [the generated task index](/src/lib/docs/tasks.md).
+
+```bash
+gro dev # start developing in watch mode
+gro dev -- vite --port 3003 # forward args by separating sections with --
+```
+
+```bash
+gro build # build everything for production
+```
+
+[Testing](/src/lib/docs/test.md) with [`uvu`](https://github.com/lukeed/uvu),
+including shims for [SvelteKit modules](https://kit.svelte.dev/docs/modules):
+
+```bash
+gro test # run all tests for `*.test.ts` files with `uvu`
+gro test filepattern1 some.test another.test
+gro test -- uvu --forwarded_args 'to uvu'
+```
+
+Check all the things:
+
+```bash
+gro check # does all of the following:
+gro typecheck # typecheck JS/TypeScript and Svelte
+gro test # run tests
+gro gen --check # ensure generated files are current
+gro format --check # ensure everything is formatted
+gro lint # eslint
+```
+
+For a usage example see [the `check.yml` CI config](.github/workflows/check.yml).
+
+Formatting with [`prettier`](https://github.com/prettier/prettier):
+
+```bash
+gro format # format all of the source files using Prettier
+gro format --check # check that all source files are formatted
+```
+
+Codegen with [`gen`](/src/lib/docs/gen.md):
+
+```bash
+gro gen # run codegen for all `*.gen.*` files
+gro gen --check # error if any generated files are new or different
+```
+
+To deploy: (also see [`src/lib/docs/deploy.md`](/src/lib/docs/deploy.md))
+
+```bash
+gro deploy # build and push to the `deploy` branch
+```
+
+To publish: (also see [`src/lib/docs/publish.md`](/src/lib/docs/publish.md))
+
+```bash
+gro publish # flush changeset to changelog, bump version, publish to npm, and git push
+```
+
+Etc:
+
+```bash
+gro clean # delete all build artifacts from the filesystem
+gro clean --sveltekit --nodemodules --git # also deletes dirs and prunes git branches
+gro upgrade excluded-dep-1 excluded-dep-2 # npm updates to the latest everything
+```
+
+```bash
+gro --version # print the Gro version
+```
+
+For more see [`src/lib/docs/task.md`](/src/lib/docs/task.md) and [`src/lib/docs`](/src/lib/docs).
+
+## develop
+
+```bash
+npm i
+npm run build # build and link `gro` - needed only once
+gro build # same as `npm run build` when the `gro` CLI is available
+gro test # make sure everything looks good - same as `npm test`
+gro test some.test another.test
+
+# use your development version of `gro` locally in another project:
+gro build # updates the `gro` CLI, same as `npm run build`
+cd ../otherproject
+npm link ../gro # from `otherproject/`
+gro build # from `../gro` on changes
+```
+
+## credits 🐢<sub>🐢</sub><sub><sub>🐢</sub></sub>
+
+Gro builds on
+[TypeScript](https://github.com/microsoft/TypeScript) ∙
+[Svelte](https://github.com/sveltejs/svelte) ∙
+[SvelteKit](https://github.com/sveltejs/kit) ∙
+[Vite](https://github.com/vitejs/vite) ∙
+[esbuild](https://github.com/evanw/esbuild) ∙
+[uvu](https://github.com/lukeed/uvu) ∙
+[mri](https://github.com/lukeed/mri) ∙
+[chokidar](https://github.com/paulmillr/chokidar) ∙
+[zod](https://github.com/colinhacks/zod) ∙
+[@ryanatkn/belt](https://github.com/ryanatkn/belt) ∙
+[ESLint](https://github.com/eslint/eslint) ∙
+[Prettier](https://github.com/prettier/prettier) ∙
+[svelte-check](https://github.com/sveltejs/language-tools/tree/master/packages/svelte-check) &
+[more](package.json)
+
+## license [🐦](https://wikipedia.org/wiki/Free_and_open-source_software)
+
+[MIT](LICENSE)

package/dist/args.d.ts

@@ -0,0 +1,59 @@
+import type { z } from 'zod';
+/**
+ * These extend the CLI args for tasks.
+ * Anything can be assigned to a task's `args`. It's just a mutable POJO dictionary.
+ * Downstream tasks will see args that upstream events mutate,
+ * unless `invoke_task` is called with modified args.
+ * Upstream tasks can use listeners to respond to downstream events and values.
+ * It's a beautiful mutable spaghetti mess. cant get enough
+ * The raw CLI ares are handled by `mri` - https://github.com/lukeed/mri
+ */
+export interface Args {
+    _?: string[];
+    help?: boolean;
+    [key: string]: Arg_Value;
+}
+export type Arg_Value = string | number | boolean | undefined | Array<string | number | boolean>;
+export interface Arg_Schema {
+    type: string;
+    default: Arg_Value;
+    description: string;
+}
+/**
+ * Parses user input args with a Zod schema.
+ * Sets the correct source of truth for `no-` versions of args,
+ * to the opposite of the unprefixed versions when not included in `unparsed_args`.
+ * This is needed because CLI args don't have a normal way of setting falsy values,
+ * so instead the args parser `mri` will pass through the truthy versions of args
+ * without the `no-` prefix.
+ * When we declare task args schemas,
+ * we need include both versions with their defaults to get correct `--help` output.
+ * Parsing like this also ensures data consistency for both versions because `mri` only creates one.
+ * A simpler implementation could replace `mri`, but it handles some finicky details well.
+ */
+export declare const parse_args: <TOutput extends Record<string, Arg_Value> = Args, TInput extends Record<string, Arg_Value> = Args>(unparsed_args: TInput, schema: z.ZodType<TOutput, z.ZodTypeDef, TInput>) => z.SafeParseReturnType<TInput, TOutput>;
+/**
+ * Serializes parsed `Args` for CLI commands.
+ */
+export declare const serialize_args: (args: Args) => string[];
+/**
+ * Parses `task_name` and `args` from `process.argv` using `mri`,
+ * ignoring anything after any `--`.
+ */
+export declare const to_task_args: (argv?: string[]) => {
+    task_name: string;
+    args: Args;
+};
+/**
+ * Gets the array of raw string args starting with the first `--`, if any.
+ */
+export declare const to_raw_rest_args: (argv?: string[]) => string[];
+/**
+ * Parses `process.argv` for the specified `command`, so given
+ * `gro taskname arg1 --arg2 -- eslint eslintarg1 --eslintarg2 -- tsc --tscarg1 --tscarg2`
+ * the `command` `'eslint'` returns `eslintarg1 --eslintarg2`
+ * and `'tsc'` returns `--tscarg1` and `--tscarg2`.
+ */
+export declare const to_forwarded_args: (command: string, raw_rest_args?: string[], cache?: Record<string, Args>) => Args;
+export declare const to_forwarded_args_by_command: (raw_rest_args?: string[]) => Record<string, Args>;
+export declare const print_command_args: (serialized_args: string[]) => string;

package/dist/args.js

@@ -0,0 +1,132 @@
+import { magenta } from 'kleur/colors';
+import mri from 'mri';
+/**
+ * Parses user input args with a Zod schema.
+ * Sets the correct source of truth for `no-` versions of args,
+ * to the opposite of the unprefixed versions when not included in `unparsed_args`.
+ * This is needed because CLI args don't have a normal way of setting falsy values,
+ * so instead the args parser `mri` will pass through the truthy versions of args
+ * without the `no-` prefix.
+ * When we declare task args schemas,
+ * we need include both versions with their defaults to get correct `--help` output.
+ * Parsing like this also ensures data consistency for both versions because `mri` only creates one.
+ * A simpler implementation could replace `mri`, but it handles some finicky details well.
+ */
+export const parse_args = (unparsed_args, schema) => {
+    const parsed = schema.safeParse(unparsed_args);
+    if (parsed.success) {
+        // mutate `data` with the correct source of truth for `no-` prefixed args
+        const { data } = parsed;
+        for (const key in parsed.data) {
+            if (key.startsWith('no-')) {
+                const base_key = key.substring(3);
+                if (!(key in unparsed_args)) {
+                    data[key] = !data[base_key];
+                }
+                else if (!(base_key in unparsed_args)) {
+                    data[base_key] = !data[key];
+                }
+            }
+        }
+    }
+    return parsed;
+};
+/**
+ * Serializes parsed `Args` for CLI commands.
+ */
+export const serialize_args = (args) => {
+    const result = [];
+    const add_value = (name, value) => {
+        if (value === undefined)
+            return;
+        result.push(name);
+        if (typeof value !== 'boolean') {
+            result.push(value + '');
+        }
+    };
+    let _ = null;
+    for (const [key, value] of Object.entries(args)) {
+        if (key === '_') {
+            _ = value ? value.map((v) => (v === undefined ? '' : v + '')) : [];
+        }
+        else {
+            const name = `${key.length === 1 ? '-' : '--'}${key}`;
+            if (Array.isArray(value)) {
+                for (const v of value)
+                    add_value(name, v);
+            }
+            else {
+                add_value(name, value);
+            }
+        }
+    }
+    return _ ? [..._, ...result] : result;
+};
+/**
+ * Parses `task_name` and `args` from `process.argv` using `mri`,
+ * ignoring anything after any `--`.
+ */
+export const to_task_args = (argv = process.argv) => {
+    const forwarded_index = argv.indexOf('--');
+    const args = mri(forwarded_index === -1 ? argv.slice(2) : argv.slice(2, forwarded_index));
+    const task_name = args._.shift() || '';
+    if (!args._.length)
+        delete args._; // enable schema defaults
+    return { task_name, args };
+};
+/**
+ * Gets the array of raw string args starting with the first `--`, if any.
+ */
+export const to_raw_rest_args = (argv = process.argv) => {
+    const forwarded_index = argv.indexOf('--');
+    return forwarded_index === -1 ? [] : argv.slice(forwarded_index);
+};
+/**
+ * Parses `process.argv` for the specified `command`, so given
+ * `gro taskname arg1 --arg2 -- eslint eslintarg1 --eslintarg2 -- tsc --tscarg1 --tscarg2`
+ * the `command` `'eslint'` returns `eslintarg1 --eslintarg2`
+ * and `'tsc'` returns `--tscarg1` and `--tscarg2`.
+ */
+export const to_forwarded_args = (command, raw_rest_args, cache = to_forwarded_args_by_command(raw_rest_args)) => cache[command] || {};
+export const to_forwarded_args_by_command = (raw_rest_args = to_raw_rest_args()) => {
+    // Parse each segment of `argv` separated by `--`.
+    const argvs = [];
+    let arr;
+    for (const arg of raw_rest_args) {
+        if (arg === '--') {
+            if (arr?.length)
+                argvs.push(arr);
+            arr = [];
+        }
+        else if (!arr) {
+            continue;
+        }
+        else if (arg) {
+            arr.push(arg);
+        }
+    }
+    if (arr?.length)
+        argvs.push(arr);
+    // Add each segment of parsed `argv` keyed by the first rest arg,
+    // which is assumed to be the CLI command that gets forwarded the args.
+    const forwarded_args_by_command = {};
+    for (const argv of argvs) {
+        const args = mri(argv);
+        let command = args._.shift();
+        if (!command) {
+            throw Error(`Malformed args following a \`--\`. Expected a rest arg command: \`${argv.join(' ')}\``);
+        }
+        // Gro commands get combined with their task name.
+        if (command === 'gro') {
+            if (!args._.length) {
+                throw Error(`Malformed args following a \`--\`. Expected gro taskname: \`${argv.join(' ')}\``);
+            }
+            command += ' ' + args._.shift();
+        }
+        if (!args._.length)
+            delete args._;
+        forwarded_args_by_command[command] = args;
+    }
+    return forwarded_args_by_command;
+};
+export const print_command_args = (serialized_args) => magenta('running command: ') + serialized_args.join(' ');

package/dist/args.test.d.ts

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

package/dist/args.test.js

@@ -0,0 +1,43 @@
+import mri from 'mri';
+import { suite } from 'uvu';
+import * as assert from 'uvu/assert';
+import { serialize_args, to_forwarded_args, to_forwarded_args_by_command, to_raw_rest_args, } from './args.js';
+/* test__serialize_args */
+const test__serialize_args = suite('serialize_args');
+test__serialize_args('basic behavior', () => {
+    const raw = ['a', '-i', '1', 'b', 'c', '-i', '-i', 'three'];
+    const parsed = mri(raw);
+    assert.equal(parsed, { _: ['a', 'b', 'c'], i: [1, true, 'three'] });
+    const serialized = serialize_args(parsed);
+    assert.equal(serialized, ['a', 'b', 'c', '-i', '1', '-i', '-i', 'three']); // sorted
+});
+test__serialize_args.run();
+/* test__serialize_args */
+/* test__to_forwarded_args_by_command */
+const test__to_forwarded_args_by_command = suite('to_forwarded_args_by_command');
+test__to_forwarded_args_by_command('basic behavior', () => {
+    const raw_rest_args = to_raw_rest_args(('gro taskname a b c --d -e 1 --     --    ' +
+        'eslint  a  --b    c --  ' +
+        'gro  a --a  --   ' +
+        'tsc  -b  --    ' +
+        'gro b -t2 t2a --t2 t2b --t222 2 --     --      --    ' +
+        'groc --m --n nn -- ' +
+        'gro d -b a --c 4 -- ' +
+        'gro d -b a --c 5 -- ').split(' '));
+    assert.equal(to_forwarded_args_by_command(raw_rest_args), {
+        eslint: { _: ['a'], b: 'c' },
+        'gro a': { a: true },
+        tsc: { b: true },
+        'gro b': { '2': 't2a', t: true, t2: 't2b', t222: 2 },
+        groc: { m: true, n: 'nn' },
+        'gro d': { b: 'a', c: 5 },
+    });
+    assert.equal(to_forwarded_args('gro b', raw_rest_args), {
+        '2': 't2a',
+        t: true,
+        t2: 't2b',
+        t222: 2,
+    });
+});
+test__to_forwarded_args_by_command.run();
+/* test__to_forwarded_args_by_command */

package/dist/build.task.d.ts

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

package/dist/build.task.js

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { Plugins } from './plugin.js';
+import { clean_fs } from './clean_fs.js';
+export const Args = z
+    .object({
+    install: z.boolean({ description: 'run npm install before building' }).default(false),
+})
+    .strict();
+export const task = {
+    summary: 'build the project',
+    Args,
+    run: async (ctx) => {
+        const { args, invoke_task } = ctx;
+        const { install } = args;
+        await invoke_task('sync', { install });
+        // TODO possibly detect if the git workspace is clean, and ask for confirmation if not,
+        // because we're not doing things like `gro gen` here because that's a dev/CI concern
+        await clean_fs({ build_dist: true });
+        const plugins = await Plugins.create({ ...ctx, dev: false, watch: false });
+        await plugins.setup();
+        await plugins.adapt();
+        await plugins.teardown();
+    },
+};

package/dist/changelog.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Updates a changelog produced by `@changesets/changelog-git` with better links and formatting.
+ * It's similar to `@changesets/changelog-github` but doesn't require a token for light usage.
+ * This may be better implemented as a standalone dependency
+ * as an alternative to `@changesets/changelog-git`.
+ * @returns boolean indicating if the changelog changed
+ */
+export declare const update_changelog: (owner: string, repo: string, path?: string, token?: string, log?: any, cache?: Fetch_Value_Cache) => Promise<boolean>;

package/dist/changelog.js

@@ -0,0 +1,47 @@
+import { readFile, writeFile } from 'fs/promises';
+import { z } from 'zod';
+import { github_fetch_commit_prs } from './github.js';
+/**
+ * Updates a changelog produced by `@changesets/changelog-git` with better links and formatting.
+ * It's similar to `@changesets/changelog-github` but doesn't require a token for light usage.
+ * This may be better implemented as a standalone dependency
+ * as an alternative to `@changesets/changelog-git`.
+ * @returns boolean indicating if the changelog changed
+ */
+export const update_changelog = async (owner, repo, path = 'CHANGELOG.md', token, log, cache = new Map()) => {
+    const contents = await readFile(path, 'utf8');
+    const parsed = parse_changelog(contents);
+    const mapped = await map_changelog(parsed, owner, repo, token, log, cache);
+    const updated = serialize_changelog(mapped);
+    if (contents === updated) {
+        return false;
+    }
+    await writeFile(path, updated, 'utf8');
+    return true;
+};
+// keeping this really simple for now, no need to parse further for our current usecases
+const Parsed_Changelog = z.array(z.string());
+const parse_changelog = (contents) => contents.split('\n');
+const serialize_changelog = (parsed) => parsed.join('\n');
+const LINE_WITH_SHA_MATCHER = /^- ([a-z0-9]{7,8}): /u;
+const map_changelog = async (parsed, owner, repo, token, log, cache) => {
+    const mapped = [];
+    for (const line of parsed) {
+        const matches = LINE_WITH_SHA_MATCHER.exec(line);
+        if (matches) {
+            const commit_sha = matches[1];
+            const l = '- ' + line.substring(commit_sha.length + 4);
+            const prs = await github_fetch_commit_prs(owner, repo, commit_sha, token, log, cache); // eslint-disable-line no-await-in-loop
+            if (prs?.length) {
+                mapped.push(`${l} (${prs.map((p) => `[#${p.number}](${p.html_url})`).join(', ')})`);
+            }
+            else {
+                mapped.push(`${l} ([${commit_sha}](https://github.com/${owner}/${repo}/commit/${commit_sha}))`);
+            }
+        }
+        else {
+            mapped.push(line);
+        }
+    }
+    return mapped;
+};

package/dist/changelog.test.d.ts

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