@gjsify/cli 0.64.14 → 0.64.15-next.287

package/lib/commands/release-notes.d.ts

@@ -2,6 +2,7 @@ import type { Command } from '../types/index.js';
 interface ReleaseNotesOptions {
     release?: string;
     compare?: boolean;
+    metainfo?: string;
 }
 export declare const releaseNotesCommand: Command<unknown, ReleaseNotesOptions>;
 export {};

package/lib/commands/release-notes.js

@@ -1,4 +1,4 @@
-// `gjsify release-notes [release] [--compare]`
+// `gjsify release-notes [release] [--compare] [--metainfo <path>]`
 //
 // Prints one `releases` entry as GitHub Markdown, so a release workflow can pass
 // it to `gh release create --notes-file -` instead of an empty body. Exits 1 when
@@ -6,11 +6,12 @@
 // rather than publish nothing.
 import { Config } from '../config.js';
 import { readPackageJson } from '../utils/pkg-json.js';
-import { renderReleaseNotes, stripVersionPrefix } from '../utils/release-notes.js';
-import { join } from 'node:path';
+import { renderReleaseNotes, resolveReleases, stripVersionPrefix } from '../utils/release-notes.js';
+import { readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
 export const releaseNotesCommand = {
     command: 'release-notes [release]',
-    description: 'Print the `releases` entry for a version as GitHub Markdown. Fails when there is no entry or no description.',
+    description: 'Print the `releases` entry for a version as GitHub Markdown (from the config or a metainfo file). Fails when there is no entry or no description.',
     builder: (yargs) => yargs
         .positional('release', {
         description: 'Version or tag (a leading `v` is accepted). Default: the version in package.json.',
@@ -20,6 +21,11 @@ export const releaseNotesCommand = {
         description: 'Append a `**Full changelog:**` compare link to the previous entry (needs `vcsBrowserUrl`).',
         type: 'boolean',
         default: false,
+    })
+        .option('metainfo', {
+        description: 'Read the `<release>` entries from this AppStream metainfo file instead of the config. ' +
+            'Default without `releases` in the config: the file named by `gjsify.site.metainfo`.',
+        type: 'string',
     }),
     handler: async (args) => {
         const projectDir = process.cwd();
@@ -30,9 +36,21 @@ export const releaseNotesCommand = {
             const version = args.release ?? readPackageJson(join(projectDir, 'package.json'))?.version;
             if (!version)
                 throw new Error('no version given and package.json has none');
-            const releases = ship.releases ?? flatpak.releases;
+            const { releases, source } = resolveReleases({
+                metainfo: args.metainfo,
+                configReleases: ship.releases ?? flatpak.releases,
+                siteMetainfo: config.site?.metainfo,
+                readMetainfo: (path) => {
+                    try {
+                        return readFileSync(resolve(projectDir, path), 'utf8');
+                    }
+                    catch {
+                        throw new Error(`cannot read the metainfo file ${path}`);
+                    }
+                },
+            });
             const repoUrl = args.compare === true ? (ship.vcsBrowserUrl ?? flatpak.vcsBrowserUrl) : undefined;
-            process.stdout.write(renderReleaseNotes({ releases, version: stripVersionPrefix(version), repoUrl }));
+            process.stdout.write(renderReleaseNotes({ releases, source, version: stripVersionPrefix(version), repoUrl }));
         }
         catch (err) {
             process.stderr.write(`gjsify release-notes: ${err instanceof Error ? err.message : String(err)}\n`);

package/lib/types/config-data.d.ts

@@ -216,6 +216,13 @@ export interface ConfigData {
      * (ADR 0024 § 8) and no project should have to write it twice.
      */
     ship?: ConfigDataShip;
+    /**
+     * Config for `gjsify site`, owned and validated by `@gjsify/site`. Only the metainfo path is
+     * typed here: `gjsify release-notes` reads releases from it when the config has none.
+     */
+    site?: {
+        metainfo?: string;
+    };
     /**
      * Config for `gjsify format` / `lint` / `fix`. A thin shell: oxc's own
      * `.oxfmtrc.json` / `.oxlintrc.json` are the real configuration files.

package/lib/utils/metainfo-releases.d.ts

@@ -0,0 +1,3 @@
+import type { ReleaseEntry } from './release-notes.js';
+/** Document order is kept: metainfo lists the newest release first, which `--compare` relies on. */
+export declare function parseMetainfoReleases(xml: string): ReleaseEntry[];

package/lib/utils/metainfo-releases.js

@@ -0,0 +1,95 @@
+// The `<release>` entries of a hand-written AppStream metainfo file, in the shape of the config's
+// `releases`, for `gjsify release-notes`.
+//
+// Apps that keep the file by hand (`gjsify.site.metainfo`) have no `releases` in the config, but the
+// file holds the same data. The tokeniser is the one `gjsify flatpak check` uses; this module only
+// adds the part that one throws away: inline markup, which a release note needs as Markdown.
+import { scanXml } from '@gjsify/utils/core';
+/** Strip the legacy intltool `_` prefix (`<_description>`), which `.metainfo.xml.in` files still use. */
+const normName = (name) => (name.startsWith('_') ? name.slice(1) : name);
+function buildTree(xml) {
+    const root = { name: '#root', attrs: {}, nodes: [] };
+    const stack = [root];
+    for (const token of scanXml(xml)) {
+        const top = stack[stack.length - 1];
+        if (token.kind === 'text') {
+            top.nodes.push(token.text);
+        }
+        else if (token.kind === 'open') {
+            const element = { name: normName(token.name), attrs: token.attributes, nodes: [] };
+            top.nodes.push(element);
+            if (!token.selfClosing)
+                stack.push(element);
+        }
+        else if (stack.length > 1) {
+            stack.pop();
+        }
+    }
+    return root;
+}
+const elements = (parent, name) => parent.nodes.filter((node) => typeof node !== 'string' && (name === undefined || node.name === name));
+/** A translation (`xml:lang`) of the untagged element before it; the untagged one is the source. */
+const isTranslation = (element) => element.attrs['xml:lang'] !== undefined;
+const INLINE_WRAP = { em: '*', i: '*', strong: '**', b: '**', code: '`', tt: '`' };
+function inlineMarkdown(element) {
+    let out = '';
+    for (const node of element.nodes) {
+        if (typeof node === 'string') {
+            out += node;
+            continue;
+        }
+        if (isTranslation(node))
+            continue;
+        const inner = inlineMarkdown(node);
+        const wrap = INLINE_WRAP[node.name];
+        if (wrap !== undefined)
+            out += inner.trim() === '' ? inner : `${wrap}${inner.trim()}${wrap}`;
+        else if (node.name === 'a' && node.attrs.href)
+            out += `[${inner}](${node.attrs.href})`;
+        else
+            out += inner;
+    }
+    return out;
+}
+const clean = (text) => text.replace(/\s+/g, ' ').trim();
+function parseBlocks(description) {
+    const blocks = [];
+    for (const element of elements(description)) {
+        if (isTranslation(element))
+            continue;
+        if (element.name === 'p') {
+            const text = clean(inlineMarkdown(element));
+            if (text)
+                blocks.push({ p: text });
+        }
+        else if (element.name === 'ul' || element.name === 'ol') {
+            const items = elements(element, 'li')
+                .filter((li) => !isTranslation(li))
+                .map((li) => clean(inlineMarkdown(li)))
+                .filter(Boolean);
+            if (items.length)
+                blocks.push({ ul: items });
+        }
+    }
+    return blocks;
+}
+/** Document order is kept: metainfo lists the newest release first, which `--compare` relies on. */
+export function parseMetainfoReleases(xml) {
+    const component = elements(buildTree(xml), 'component')[0];
+    if (!component)
+        throw new Error('metainfo root must be <component>');
+    const releases = elements(component, 'releases')[0];
+    if (!releases)
+        return [];
+    return elements(releases, 'release').map((release) => {
+        const timestamp = release.attrs.timestamp;
+        const date = release.attrs.date ?? (timestamp ? new Date(Number(timestamp) * 1000).toISOString().slice(0, 10) : '');
+        const description = elements(release, 'description').find((candidate) => !isTranslation(candidate));
+        const blocks = description ? parseBlocks(description) : [];
+        return {
+            version: release.attrs.version ?? '',
+            date,
+            ...(blocks.length ? { description: blocks } : {}),
+        };
+    });
+}

package/lib/utils/release-notes.d.ts

@@ -8,12 +8,31 @@ export interface ReleaseEntry {
 export declare function descriptionToMarkdown(description: string | DescriptionBlock[]): string;
 /** `v0.1.7` and `0.1.7` name the same release. */
 export declare function stripVersionPrefix(version: string): string;
+export interface ReleasesSource {
+    /** `--metainfo <path>`: wins over everything. */
+    metainfo?: string;
+    /** `ship.releases ?? flatpak.releases` from the config. */
+    configReleases?: readonly ReleaseEntry[];
+    /** `site.metainfo` from the config: read only when nothing above names releases. */
+    siteMetainfo?: string;
+    /** Reads a metainfo file; throws when it does not exist. */
+    readMetainfo: (path: string) => string;
+}
+export interface ResolvedReleases {
+    releases: readonly ReleaseEntry[] | undefined;
+    /** Names the origin in error messages; unset for the config. */
+    source?: string;
+}
+/** Lookup order: `--metainfo`, config `releases`, the metainfo the config names. */
+export declare function resolveReleases(input: ReleasesSource): ResolvedReleases;
 export interface ReleaseNotesInput {
     releases: readonly ReleaseEntry[] | undefined;
+    /** Where `releases` came from, for the error text. Default: the gjsify config. */
+    source?: string;
     /** Requested version, with or without a leading `v`. */
     version: string;
     /** Append the compare link when set and a previous release exists. */
     repoUrl?: string;
 }
 /** Throws an `Error` whose message is meant to be printed as-is. */
-export declare function renderReleaseNotes({ releases, version, repoUrl }: ReleaseNotesInput): string;
+export declare function renderReleaseNotes({ releases, source, version, repoUrl }: ReleaseNotesInput): string;

package/lib/utils/release-notes.js

@@ -4,6 +4,7 @@
 // release, so both read the one `releases` list in the config. The string →
 // block normalisation is `stringToBlocks` from app-metadata.ts, not a second copy.
 import { stringToBlocks } from './app-metadata.js';
+import { parseMetainfoReleases } from './metainfo-releases.js';
 /** Paragraphs → paragraphs, lists → `- ` items. Translator hints are dropped. */
 export function descriptionToMarkdown(description) {
     const blocks = typeof description === 'string' ? stringToBlocks(description) : description;
@@ -26,14 +27,22 @@ export function descriptionToMarkdown(description) {
 export function stripVersionPrefix(version) {
     return version.trim().replace(/^v/i, '');
 }
+/** Lookup order: `--metainfo`, config `releases`, the metainfo the config names. */
+export function resolveReleases(input) {
+    const path = input.metainfo ?? (input.configReleases ? undefined : input.siteMetainfo);
+    if (path === undefined)
+        return { releases: input.configReleases };
+    return { releases: parseMetainfoReleases(input.readMetainfo(path)), source: path };
+}
 /** Throws an `Error` whose message is meant to be printed as-is. */
-export function renderReleaseNotes({ releases, version, repoUrl }) {
+export function renderReleaseNotes({ releases, source, version, repoUrl }) {
     const wanted = stripVersionPrefix(version);
     const list = releases ?? [];
     const index = list.findIndex((r) => stripVersionPrefix(r.version) === wanted);
     if (index < 0) {
-        throw new Error(`no \`releases\` entry for version ${wanted} in the gjsify config` +
-            (list.length ? ` (found: ${list.map((r) => r.version).join(', ')})` : ' (no `releases` configured)'));
+        const none = source === undefined ? 'no `releases` configured' : 'no `<release>` entries';
+        throw new Error(`no \`releases\` entry for version ${wanted} in ${source ?? 'the gjsify config'}` +
+            (list.length ? ` (found: ${list.map((r) => r.version).join(', ')})` : ` (${none})`));
     }
     const entry = list[index];
     const body = entry.description === undefined ? '' : descriptionToMarkdown(entry.description);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gjsify/cli",
-    "version": "0.64.14",
+    "version": "0.64.15-next.287",
     "description": "CLI for Gjsify",
     "type": "module",
     "main": "lib/index.js",
@@ -142,22 +142,22 @@
         "cli"
     ],
     "dependencies": {
-        "@gjsify/blueprint": "^0.64.14",
-        "@gjsify/buffer": "^0.64.14",
-        "@gjsify/create-app": "^0.64.14",
-        "@gjsify/node-globals": "^0.64.14",
-        "@gjsify/node-polyfills": "^0.64.14",
-        "@gjsify/npm-registry": "^0.64.14",
-        "@gjsify/resolve-npm": "^0.64.14",
-        "@gjsify/rolldown-plugin-gjsify": "^0.64.14",
-        "@gjsify/vite-plugin-blueprint": "^0.64.14",
-        "@gjsify/rolldown-plugin-pnp": "^0.64.14",
-        "@gjsify/semver": "^0.64.14",
-        "@gjsify/tar": "^0.64.14",
-        "@gjsify/tsc": "^0.64.14",
-        "@gjsify/utils": "^0.64.14",
-        "@gjsify/web-polyfills": "^0.64.14",
-        "@gjsify/workspace": "^0.64.14",
+        "@gjsify/blueprint": "0.64.15-next.287",
+        "@gjsify/buffer": "0.64.15-next.287",
+        "@gjsify/create-app": "0.64.15-next.287",
+        "@gjsify/node-globals": "0.64.15-next.287",
+        "@gjsify/node-polyfills": "0.64.15-next.287",
+        "@gjsify/npm-registry": "0.64.15-next.287",
+        "@gjsify/resolve-npm": "0.64.15-next.287",
+        "@gjsify/rolldown-plugin-gjsify": "0.64.15-next.287",
+        "@gjsify/vite-plugin-blueprint": "0.64.15-next.287",
+        "@gjsify/rolldown-plugin-pnp": "0.64.15-next.287",
+        "@gjsify/semver": "0.64.15-next.287",
+        "@gjsify/tar": "0.64.15-next.287",
+        "@gjsify/tsc": "0.64.15-next.287",
+        "@gjsify/utils": "0.64.15-next.287",
+        "@gjsify/web-polyfills": "0.64.15-next.287",
+        "@gjsify/workspace": "0.64.15-next.287",
         "acorn": "^8.17.0",
         "cosmiconfig": "^9.0.2",
         "get-tsconfig": "^4.14.0",
@@ -166,13 +166,13 @@
         "yargs": "^18.0.0"
     },
     "devDependencies": {
-        "@gjsify/unit": "^0.64.14",
+        "@gjsify/unit": "0.64.15-next.287",
         "@types/yargs": "^17.0.35",
         "typescript": "^6.0.3"
     },
     "peerDependencies": {
-        "@gjsify/oxfmt-native": "^0.64.14",
-        "@gjsify/rolldown-native": "^0.64.14"
+        "@gjsify/oxfmt-native": "0.64.15-next.287",
+        "@gjsify/rolldown-native": "0.64.15-next.287"
     },
     "peerDependenciesMeta": {
         "@gjsify/oxfmt-native": {
@@ -191,5 +191,6 @@
     "bugs": {
         "url": "https://github.com/gjsify/gjsify/issues"
     },
-    "homepage": "https://github.com/gjsify/gjsify/tree/main/packages/infra/cli#readme"
+    "homepage": "https://github.com/gjsify/gjsify/tree/main/packages/infra/cli#readme",
+    "gitHead": "5742b282a8a2bc8633dd8384ef436768447f6a83"
 }