@tallyrelease/core 0.1.1 → 0.2.0

package/dist/release.js

@@ -0,0 +1,368 @@
+import { compare, maxLevel, uniqueSorted } from "./util.js";
+const DEFAULT_TYPES = {
+    feat: "minor",
+    fix: "patch",
+    perf: "patch",
+    revert: "patch",
+};
+/** Release-As values per commit for one unit, in range order. */
+const commitValues = (id, changes) => {
+    const commits = new Map();
+    changes.forEach(({ change, units }, i) => {
+        const key = change.sha ?? `#${String(i)}`;
+        const entry = commits.get(key) ?? {
+            ...(change.sha === undefined ? {} : { sha: change.sha }),
+            qualified: [],
+            plain: [],
+        };
+        commits.set(key, entry);
+        for (const r of change.releaseAs ?? []) {
+            if (r.unit === id) {
+                entry.qualified.push(r.version);
+            }
+            else if (r.unit === undefined && units.includes(id)) {
+                entry.plain.push(r.version);
+            }
+        }
+    });
+    return [...commits.values()].map(({ qualified, plain, ...rest }) => ({
+        ...rest,
+        values: qualified.length > 0 ? qualified : plain,
+    }));
+};
+const at = (sha) => (sha === undefined ? "" : ` in ${sha}`);
+/** A Release-As value without a single leading `v`, parsed by the scheme. */
+const parseReleaseAs = (scheme, raw) => scheme.parse(raw.startsWith("v") ? raw.slice(1) : raw);
+/** Why a parsed Release-As value is ignored, else undefined. */
+const releaseAsProblem = (scheme, version, from) => {
+    if (scheme.isPrerelease(version)) {
+        return "is a prerelease";
+    }
+    return from && scheme.compare(version, from.version) <= 0
+        ? `does not exceed ${from.label}`
+        : undefined;
+};
+/** Newest valid value wins; invalid values and other values warn. */
+const pickReleaseAs = (input, warnings) => {
+    const { unit, scheme, from, commits } = input;
+    let winner;
+    for (const { sha, values } of commits) {
+        for (const raw of values) {
+            const version = parseReleaseAs(scheme, raw);
+            const problem = version === undefined
+                ? `is not a ${unit.scheme} version`
+                : releaseAsProblem(scheme, version, from);
+            if (problem !== undefined || version === undefined) {
+                warnings.push({
+                    code: "W_RELEASE_AS_INVALID",
+                    message: `unit "${unit.id}": Release-As "${raw}"${at(sha)} ${problem ?? ""}; ignored`,
+                    unit: unit.id,
+                });
+            }
+            else if (!winner) {
+                winner = { ...(sha === undefined ? {} : { sha }), raw, version };
+            }
+            else if (scheme.compare(version, winner.version) !== 0) {
+                warnings.push({
+                    code: "W_RELEASE_AS_CONFLICT",
+                    message: `unit "${unit.id}": Release-As "${winner.raw}"${at(winner.sha)} wins over "${raw}"${at(sha)}`,
+                    unit: unit.id,
+                });
+            }
+        }
+    }
+    return winner;
+};
+/**
+ * Level of one change. While the major is 0, breaking changes use
+ * `preMajor.breaking` and changes whose type level is minor `preMajor.feat`.
+ * An absorbed change contributes `bumps.absorbed` when its own level is set
+ * (`minor` caps it at minor).
+ */
+const changeLevel = ({ change, via }, settings, preMajor) => {
+    const typed = settings.bumps.get(change.type) ?? null;
+    const level = change.breaking
+        ? preMajor
+            ? settings.preMajor.breaking
+            : "major"
+        : preMajor && typed === "minor"
+            ? settings.preMajor.feat
+            : typed;
+    if (via === undefined || level === null) {
+        return level;
+    }
+    return settings.absorbed === "minor" && level !== "patch" ? "minor" : "patch";
+};
+/** Max level over the changes. */
+const ownBump = (changes, settings, preMajor) => changes.reduce((bump, change) => maxLevel(bump, changeLevel(change, settings, preMajor)), null);
+/** Changes of the range attributed to the unit or to an absorbed unit. */
+const unitChanges = (id, range, absorbed) => range.changes.flatMap(({ change, units }) => {
+    if (units.includes(id)) {
+        return [{ change }];
+    }
+    const via = units.find((u) => absorbed.has(u));
+    return via === undefined ? [] : [{ change, via }];
+});
+/** Warns when a first release's initial version is not above the unit's highest prerelease tag. */
+const initialBelowPrerelease = (scheme, initial, facts) => {
+    const highest = facts.tags
+        .filter((t) => {
+        const v = scheme.parse(t.version);
+        return v !== undefined && scheme.isPrerelease(v);
+    })
+        .at(-1);
+    const version = highest && scheme.parse(highest.version);
+    if (!highest || version === undefined) {
+        return [];
+    }
+    return scheme.compare(initial, version) > 0
+        ? []
+        : [
+            {
+                code: "W_INITIAL_BELOW_PRERELEASE",
+                message: `unit "${facts.id}": initial version ${scheme.format(initial)} does not exceed prerelease tag "${highest.name}"`,
+                unit: facts.id,
+            },
+        ];
+};
+/** Normalized value of the first valid Release-As of a commit. */
+const appliedValue = (scheme, values) => {
+    for (const raw of values) {
+        const version = parseReleaseAs(scheme, raw);
+        if (version !== undefined && !scheme.isPrerelease(version)) {
+            return scheme.format(version);
+        }
+    }
+    return undefined;
+};
+/** The `from` version of a unit, from `facts.fromTag`. */
+const fromOf = (scheme, facts) => {
+    const tag = facts.fromTag;
+    const version = tag === null ? undefined : scheme.parse(tag.version);
+    return tag === null || version === undefined
+        ? undefined
+        : {
+            version,
+            label: facts.group === null
+                ? tag.version
+                : `${tag.version} (group ${facts.group})`,
+        };
+};
+/** `from` bumped by `bump`; the initial version on a first release. */
+const bumpedOf = (scheme, bump, { from, initial }) => bump === null
+    ? undefined
+    : from === undefined
+        ? initial
+        : scheme.bump(from.version, bump);
+const ctxOf = (unit, head, at) => ({
+    unit,
+    head,
+    baseTag: at.baseTag?.name ?? null,
+    tags: at.tags,
+    firstParent: { sinceLineBase: at.sinceLineBase, total: at.total },
+});
+const initialOf = (unit, scheme) => (unit.initialVersion === null
+    ? undefined
+    : scheme.parse(unit.initialVersion)) ?? scheme.initial();
+/** `next` and prerelease of `raw` under `ctx`. */
+const render = ({ scheme, raw, ctx, channel, }) => ({
+    next: raw === undefined ? null : scheme.format(scheme.release(raw, ctx)),
+    prerelease: raw === undefined || channel === null
+        ? null
+        : scheme.format(scheme.prerelease(raw, { ...ctx, channel })),
+});
+/**
+ * Unreleased units reachable over `id`'s dependencies, never stepping into or
+ * through a released unit.
+ */
+export const reach = (id, dependencies, released) => {
+    const found = new Set();
+    const queue = [id];
+    for (const v of queue) {
+        for (const w of dependencies.get(v) ?? []) {
+            if (!released.has(w) && !found.has(w)) {
+                found.add(w);
+                queue.push(w);
+            }
+        }
+    }
+    return found;
+};
+/** Applies the defaults to `bumps` and `branches`. */
+export const releaseSettings = (config) => ({
+    bumps: new Map(Object.entries({ ...DEFAULT_TYPES, ...config.bumps?.types })),
+    absorbed: config.bumps?.absorbed ?? "patch",
+    preMajor: {
+        breaking: config.bumps?.preMajor?.breaking ?? "minor",
+        feat: config.bumps?.preMajor?.feat ?? "minor",
+    },
+    branches: (config.branches ?? []).map((b) => ({
+        name: b.name,
+        line: b.line,
+        channel: b.channel ?? null,
+        unit: b.unit ?? null,
+        group: b.group ?? null,
+    })),
+});
+/**
+ * Warns for qualified Release-As values naming unknown or unreleased units and
+ * for plain values on commits attributed to no released unit.
+ */
+export const releaseAsWarnings = (units, ranges) => {
+    const known = new Set(units.map((u) => u.id));
+    const released = new Set(units.filter((u) => u.version !== "none").map((u) => u.id));
+    const warnings = new Map();
+    const warn = (code, message, unit) => {
+        warnings.set(`${code}\0${message}`, {
+            code,
+            message,
+            ...(unit === undefined ? {} : { unit }),
+        });
+    };
+    for (const { changes } of ranges) {
+        for (const { change, units: owners } of changes) {
+            for (const { unit, version } of change.releaseAs ?? []) {
+                if (unit === undefined) {
+                    if (!owners.some((id) => released.has(id))) {
+                        warn("W_RELEASE_AS_IGNORED", `Release-As "${version}"${at(change.sha)} is not attributed to a released unit`);
+                    }
+                }
+                else if (!known.has(unit)) {
+                    warn("W_RELEASE_AS_UNKNOWN", `Release-As "${unit}@${version}"${at(change.sha)} names unknown unit "${unit}"`);
+                }
+                else if (!released.has(unit)) {
+                    warn("W_RELEASE_AS_IGNORED", `Release-As "${unit}@${version}"${at(change.sha)} names unreleased unit "${unit}"`, unit);
+                }
+            }
+        }
+    }
+    return [...warnings.values()];
+};
+/**
+ * Own and absorbed bump and Release-As of a released unit. Release-As values
+ * are read newest first (core commit order); a single leading `v` is
+ * stripped, as release-please does. Footers are not absorbed.
+ */
+export const unitIntent = (input, warnings) => {
+    const { unit, scheme, facts } = input;
+    const from = fromOf(scheme, facts);
+    const changes = unitChanges(unit.id, input.range, input.absorbed);
+    const commits = commitValues(unit.id, input.range.changes);
+    return {
+        bump: ownBump(changes, input.settings, from !== undefined && scheme.core(from.version).major === 0),
+        releaseAs: pickReleaseAs({ unit, scheme, from, commits }, warnings),
+        changes,
+        absorbedFrom: uniqueSorted(input.range.changes.flatMap(({ units }) => units.includes(unit.id)
+            ? []
+            : units.filter((u) => input.absorbed.has(u)))),
+        releaseAsBySha: new Map(commits.flatMap(({ sha, values }) => {
+            const value = appliedValue(scheme, values);
+            return sha === undefined || value === undefined ? [] : [[sha, value]];
+        })),
+    };
+};
+/** The recorded footer of a Release-As winner. */
+export const footerOf = (winner) => winner
+    ? {
+        ...(winner.sha === undefined ? {} : { sha: winner.sha }),
+        raw: winner.raw,
+    }
+    : null;
+/**
+ * `next` and prerelease of a released unit from its bump after propagation;
+ * Release-As overrides `next`.
+ */
+export const releaseUnit = (input, intent, warnings) => {
+    const { unit, scheme, facts } = input;
+    const { bump } = intent;
+    const releaseAs = intent.releaseAs?.version;
+    const from = fromOf(scheme, facts);
+    const initial = initialOf(unit, scheme);
+    const bumped = bumpedOf(scheme, bump, { from, initial });
+    if (from === undefined && releaseAs === undefined && bumped !== undefined) {
+        warnings.push(...initialBelowPrerelease(scheme, initial, facts));
+    }
+    const raw = releaseAs ?? bumped;
+    return {
+        from: facts.baseTag?.version ?? null,
+        bump,
+        releaseAs: releaseAs === undefined ? null : scheme.format(releaseAs),
+        releaseAsFooter: footerOf(intent.releaseAs),
+        nextSource: raw === undefined
+            ? null
+            : releaseAs !== undefined
+                ? "release-as"
+                : from === undefined
+                    ? "initial"
+                    : "bump",
+        ...render({
+            scheme,
+            raw,
+            ctx: ctxOf(unit, input.head, {
+                ...facts,
+                tags: facts.tags.map((t) => t.name),
+            }),
+            channel: input.channel,
+        }),
+    };
+};
+/**
+ * Release of a fixed group with members sorted by id:
+ * `next = max(bump(groupFrom, L), max_i releaseAs_i)`, the initial version
+ * (max over members) instead of the bump on a first release. One `PreCtx`:
+ * first member, group base tag, union of member tags, group line base
+ * counter, max total.
+ */
+export const releaseGroup = (group, members, warnings) => {
+    const [first] = members;
+    if (!first) {
+        throw new TypeError("a group has at least one member");
+    }
+    const { scheme, facts, channel, head } = first.input;
+    const max = (a, b) => a === undefined || (b !== undefined && scheme.compare(b, a) > 0) ? b : a;
+    const from = fromOf(scheme, facts);
+    const bump = members.reduce((level, m) => maxLevel(level, m.bump), null);
+    const releaseAs = members.reduce((value, m) => max(value, m.releaseAs?.version), undefined);
+    const initial = members.reduce((value, m) => max(value, initialOf(m.input.unit, scheme)) ?? value, initialOf(first.input.unit, scheme));
+    const bumped = bumpedOf(scheme, bump, { from, initial });
+    if (from === undefined && releaseAs === undefined && bumped !== undefined) {
+        for (const m of members) {
+            warnings.push(...initialBelowPrerelease(scheme, initial, m.input.facts));
+        }
+    }
+    const tags = members
+        .flatMap((m) => m.input.facts.tags)
+        .flatMap((t) => {
+        const version = scheme.parse(t.version);
+        return version === undefined ? [] : [{ name: t.name, version }];
+    })
+        .sort((a, b) => scheme.compare(a.version, b.version) || compare(a.name, b.name))
+        .map((t) => t.name);
+    const raw = max(bumped, releaseAs);
+    const byReleaseAs = releaseAs !== undefined &&
+        (bumped === undefined || scheme.compare(releaseAs, bumped) > 0);
+    return {
+        from: group.baseTag?.version ?? null,
+        bump,
+        releaseAs: releaseAs === undefined ? null : scheme.format(releaseAs),
+        nextSource: raw === undefined
+            ? null
+            : byReleaseAs
+                ? "release-as"
+                : from === undefined
+                    ? "initial"
+                    : "bump",
+        ...render({
+            scheme,
+            raw,
+            ctx: ctxOf(first.input.unit, head, {
+                baseTag: group.baseTag,
+                tags,
+                sinceLineBase: group.sinceLineBase,
+                total: Math.max(...members.map((m) => m.input.facts.total)),
+            }),
+            channel,
+        }),
+    };
+};
+export { changeLevel };

package/dist/schemes.d.ts

@@ -0,0 +1,12 @@
+import type { Plugin, VersionScheme } from "./plugin.js";
+export interface SchemeEntry {
+    readonly plugin: string;
+    readonly name: string;
+    readonly scheme: VersionScheme<any>;
+}
+/** Schemes of core and the given plugins, in that order. */
+export declare const collectSchemes: (active: readonly {
+    readonly plugin: Plugin;
+}[]) => SchemeEntry[];
+/** Name to scheme; throws `E_SCHEME_CLASH` on a duplicate name. */
+export declare const schemeRegistry: (list: readonly SchemeEntry[]) => ReadonlyMap<string, VersionScheme<any>>;

package/dist/schemes.js

@@ -0,0 +1,22 @@
+import { corePlugin } from "./builtin.js";
+import { TallyError } from "./errors.js";
+/** Schemes of core and the given plugins, in that order. */
+export const collectSchemes = (active) => [corePlugin, ...active.map((a) => a.plugin)].flatMap((plugin) => Object.entries(plugin.schemes ?? {}).map(([name, scheme]) => ({
+    plugin: plugin.name,
+    name,
+    scheme,
+})));
+/** Name to scheme; throws `E_SCHEME_CLASH` on a duplicate name. */
+export const schemeRegistry = (list) => {
+    const owners = new Map();
+    const registry = new Map();
+    for (const { plugin, name, scheme } of list) {
+        const owner = owners.get(name);
+        if (owner !== undefined) {
+            throw new TallyError("E_SCHEME_CLASH", `scheme "${name}" is registered by "${owner}" and "${plugin}"`, { scheme: name, plugins: [owner, plugin] });
+        }
+        owners.set(name, plugin);
+        registry.set(name, scheme);
+    }
+    return registry;
+};

package/dist/semver.d.ts

@@ -0,0 +1,11 @@
+import type { VersionScheme } from "./plugin.js";
+/** A parsed SemVer 2.0 version. */
+export interface SemVer {
+    readonly major: number;
+    readonly minor: number;
+    readonly patch: number;
+    readonly prerelease: readonly (string | number)[];
+    readonly build: readonly string[];
+}
+/** SemVer 2.0 scheme; bumps follow the `semver` package `inc`. */
+export declare const semver: VersionScheme<SemVer>;

package/dist/semver.js

@@ -0,0 +1,53 @@
+import lib from "semver";
+import { TallyError } from "./errors.js";
+const format = (v) => {
+    const pre = v.prerelease.length > 0 ? `-${v.prerelease.join(".")}` : "";
+    const build = v.build.length > 0 ? `+${v.build.join(".")}` : "";
+    return `${[v.major, v.minor, v.patch].join(".")}${pre}${build}`;
+};
+/** Strict: the input must be exactly its canonical form (no `v`, no padding). */
+const parse = (raw) => {
+    const parsed = lib.parse(raw);
+    if (!parsed) {
+        return undefined;
+    }
+    const v = {
+        major: parsed.major,
+        minor: parsed.minor,
+        patch: parsed.patch,
+        prerelease: [...parsed.prerelease],
+        build: [...parsed.build],
+    };
+    return format(v) === raw ? v : undefined;
+};
+const mustParse = (raw) => {
+    const v = parse(raw);
+    if (!v) {
+        throw new TallyError("E_VERSION_INVALID", `invalid version "${raw}"`, {
+            version: raw,
+        });
+    }
+    return v;
+};
+const core = ({ major, minor, patch }) => ({ major, minor, patch });
+/** SemVer 2.0 scheme; bumps follow the `semver` package `inc`. */
+export const semver = {
+    parse,
+    format,
+    compare: (a, b) => lib.compare(format(a), format(b)),
+    core,
+    isPrerelease: (v) => v.prerelease.length > 0,
+    initial: () => ({ major: 1, minor: 0, patch: 0, prerelease: [], build: [] }),
+    bump: (v, level) => mustParse(lib.inc(format(v), level) ?? ""),
+    release: (next) => next,
+    prerelease: (next, ctx) => {
+        const { major, minor, patch } = core(next);
+        const n = String(ctx.firstParent.sinceLineBase);
+        const raw = `${[major, minor, patch].join(".")}-${ctx.channel}.${n}`;
+        const v = parse(raw);
+        if (!v) {
+            throw new TallyError("E_CHANNEL_INVALID", `channel "${ctx.channel}" does not form a valid prerelease`, { channel: ctx.channel });
+        }
+        return v;
+    },
+};

package/dist/tags.d.ts

@@ -0,0 +1,40 @@
+import type { Warning } from "./errors.js";
+import type { TagRef, Unit, VersionScheme } from "./plugin.js";
+/** A unit's `tagFormat` compiled to an anchored regex. */
+export interface TagFormat {
+    /** The format with `{id}` substituted. */
+    readonly rendered: string;
+    /** The raw `{version}` part of a matching tag, else undefined. */
+    match: (tag: string) => string | undefined;
+}
+/** A tag of a unit whose `{version}` part parses with the unit's scheme. */
+export interface UnitTag {
+    readonly name: string;
+    readonly sha: string;
+    readonly version: string;
+}
+/** Compiles `format`; literal parts and `{id}` are escaped, `{version}` must occur once. */
+export declare const compileTagFormat: (format: string, unitId: string) => TagFormat;
+/** Tags of a released unit and its scheme. */
+export interface UnitTags {
+    readonly scheme: VersionScheme<any>;
+    /** Sorted by scheme order, then name. */
+    readonly tags: UnitTag[];
+}
+/**
+ * Tags of each released unit, sorted by scheme order, then name. Unreleased
+ * units never match. Throws `E_TAG_FORMAT_OVERLAP` if two released units render
+ * the same format or a tag parses for more than one of them.
+ */
+export declare const matchUnitTags: (units: readonly Unit[], tags: readonly TagRef[], schemes: ReadonlyMap<string, VersionScheme<any>>) => Map<string, UnitTags>;
+/**
+ * Released units without a matching tag while some tag not matched by a
+ * released unit contains their id, delimited by non-alphanumeric characters
+ * or the tag's ends.
+ */
+export declare const noMatchingTag: (units: readonly Unit[], matched: readonly {
+    id: string;
+    tags: readonly {
+        name: string;
+    }[];
+}[], tagNames: readonly string[]) => Warning[];

package/dist/tags.js

@@ -0,0 +1,92 @@
+import { TallyError } from "./errors.js";
+import { compare } from "./util.js";
+const SPECIAL = /[\\^$.*+?()[\]{}|/]/gu;
+const overlap = (units, detail) => new TallyError("E_TAG_FORMAT_OVERLAP", `released units "${units.join('", "')}" share tags (${Object.values(detail).join(", ")})`, { units, ...detail });
+/** Compiles `format`; literal parts and `{id}` are escaped, `{version}` must occur once. */
+export const compileTagFormat = (format, unitId) => {
+    const parts = format.split("{version}");
+    if (parts.length !== 2) {
+        throw new TallyError("E_TAG_FORMAT", `tag format "${format}" of unit "${unitId}" must contain {version} exactly once`, { unit: unitId, format });
+    }
+    const literal = (part) => part.replaceAll("{id}", unitId).replace(SPECIAL, "\\$&");
+    const re = new RegExp(`^${literal(parts[0] ?? "")}(.+)${literal(parts[1] ?? "")}$`, "u");
+    return {
+        rendered: format.replaceAll("{id}", unitId),
+        match: (tag) => re.exec(tag)?.[1],
+    };
+};
+/**
+ * Tags of each released unit, sorted by scheme order, then name. Unreleased
+ * units never match. Throws `E_TAG_FORMAT_OVERLAP` if two released units render
+ * the same format or a tag parses for more than one of them.
+ */
+export const matchUnitTags = (units, tags, schemes) => {
+    const released = units
+        .filter((u) => u.version !== "none")
+        .map((unit) => {
+        const scheme = schemes.get(unit.scheme);
+        if (!scheme) {
+            throw new TallyError("E_SCHEME_UNKNOWN", `unit "${unit.id}" uses unknown scheme "${unit.scheme}"`, { unit: unit.id, scheme: unit.scheme });
+        }
+        return {
+            unit,
+            scheme,
+            format: compileTagFormat(unit.tagFormat, unit.id),
+        };
+    });
+    const rendered = new Map();
+    for (const { unit, format } of released) {
+        const other = rendered.get(format.rendered);
+        if (other !== undefined) {
+            throw overlap([other, unit.id], { format: format.rendered });
+        }
+        rendered.set(format.rendered, unit.id);
+    }
+    const matched = new Map(released.map((r) => [
+        r.unit.id,
+        { scheme: r.scheme, tags: [] },
+    ]));
+    for (const tag of tags) {
+        const owners = released.filter((r) => {
+            const raw = r.format.match(tag.name);
+            return raw !== undefined && r.scheme.parse(raw) !== undefined;
+        });
+        if (owners.length > 1) {
+            throw overlap(owners.map((r) => r.unit.id), { tag: tag.name });
+        }
+        const [owner] = owners;
+        const version = owner?.format.match(tag.name);
+        if (owner && version !== undefined) {
+            matched.get(owner.unit.id)?.tags.push({ ...tag, version });
+        }
+    }
+    for (const { scheme, tags: list } of matched.values()) {
+        list.sort((a, b) => scheme.compare(scheme.parse(a.version), scheme.parse(b.version)) ||
+            compare(a.name, b.name));
+    }
+    return matched;
+};
+/**
+ * Released units without a matching tag while some tag not matched by a
+ * released unit contains their id, delimited by non-alphanumeric characters
+ * or the tag's ends.
+ */
+export const noMatchingTag = (units, matched, tagNames) => {
+    const names = new Set(matched.flatMap((m) => m.tags.map((t) => t.name)));
+    const tags = tagNames.filter((t) => !names.has(t));
+    return matched.flatMap((m) => {
+        const unit = units.find((u) => u.id === m.id);
+        const id = new RegExp(`(?:^|[^A-Za-z0-9])${m.id.replace(SPECIAL, "\\$&")}(?:[^A-Za-z0-9]|$)`, "u");
+        const similar = tags.find((t) => id.test(t));
+        if (!unit || m.tags.length > 0 || similar === undefined) {
+            return [];
+        }
+        return [
+            {
+                code: "W_NO_MATCHING_TAG",
+                message: `released unit "${m.id}" has no tag matching "${unit.tagFormat.replaceAll("{id}", m.id)}", but "${similar}" contains its id`,
+                unit: m.id,
+            },
+        ];
+    });
+};

package/dist/testing.d.ts

@@ -37,6 +37,8 @@ export interface Dag {
 export interface MemoryGit extends GitReader {
     /** File contents at a commit id, tag name or `HEAD` (the last commit). */
     tree: (ref: string) => Record<string, string>;
+    /** Parent commit ids of a ref. */
+    parents: (ref: string) => string[];
 }
 /** In-memory `GitReader` over a commit graph. */
 export declare const memoryGit: (dag: Dag) => MemoryGit;
@@ -48,6 +50,7 @@ export type ReaderFactory = (dag: Dag) => MaybePromise<{
 /**
  * Shared `GitReader` spec. Fixture: a - b - d - m - e - f on the first-parent
  * chain, c branches from b and merges into m, d renames pkg/x.ts to pkg/y.ts,
- * f adds a path with a quote, a tab and a non-ASCII character.
+ * f adds a path with a quote, a tab and a non-ASCII character, g is empty and
+ * h carries footers. `a` has a later committer date than b, c and d.
  */
 export declare const gitReaderConformance: (makeReader: ReaderFactory) => void;

package/dist/testing.js

@@ -5,6 +5,7 @@ const SKIPPED = new Set([".git", "node_modules"]);
 const changed = (a, b) => uniqueSorted([...a.keys(), ...b.keys()]).filter((p) => a.get(p) !== b.get(p));
 /** Path git would C-quote without `-z`. */
 const ODD_PATH = 'odd/a "q"\tü.txt';
+const FOOTER_MESSAGE = "feat: h\n\nbody\n\nRelease-As: core@1.0.0\nRefs: #1";
 const CONFORMANCE_DAG = {
     commits: [
         {
@@ -29,6 +30,12 @@ const CONFORMANCE_DAG = {
             files: { "README.md": "e\n" },
         },
         { id: "f", message: "chore: odd", files: { [ODD_PATH]: "f\n" } },
+        { id: "g", message: "chore: empty" },
+        {
+            id: "h",
+            message: FOOTER_MESSAGE,
+            files: { "README.md": "h\n" },
+        },
     ],
     tags: [
         { name: "v1", commit: "a" },
@@ -165,12 +172,14 @@ export const memoryGit = (dag) => {
         },
         diffFiles: (from, to) => changed(node(from).tree, node(to).tree),
         tree: (ref) => Object.fromEntries(node(ref).tree),
+        parents: (ref) => [...node(ref).parents],
     };
 };
 /**
  * Shared `GitReader` spec. Fixture: a - b - d - m - e - f on the first-parent
  * chain, c branches from b and merges into m, d renames pkg/x.ts to pkg/y.ts,
- * f adds a path with a quote, a tab and a non-ASCII character.
+ * f adds a path with a quote, a tab and a non-ASCII character, g is empty and
+ * h carries footers. `a` has a later committer date than b, c and d.
  */
 export const gitReaderConformance = (makeReader) => {
     describe("GitReader conformance", () => {
@@ -238,6 +247,24 @@ export const gitReaderConformance = (makeReader) => {
             expect(Date.parse(byId("a")?.date ?? "")).toBe(Date.parse("2024-01-01T10:00:00Z"));
             expect(Date.parse(byId("e")?.date ?? "")).toBe(Date.parse("2024-01-02T12:30:00Z"));
         });
+        it("lists every commit before its parents", async () => {
+            const commits = await git.log(null, sha("e"));
+            const index = new Map(commits.map((c, i) => [c.sha, i]));
+            for (const [i, c] of commits.entries()) {
+                for (const parent of c.parents) {
+                    expect(index.get(parent) ?? Infinity).toBeGreaterThan(i);
+                }
+            }
+        });
+        it("logs empty commits and footers verbatim", async () => {
+            const commits = await git.log(sha("f"), sha("h"));
+            expect(commits.map((c) => c.sha).sort(compare)).toEqual(shas(["g", "h"]));
+            expect(commits.find((c) => c.sha === sha("g"))?.files).toEqual([]);
+            expect(commits.find((c) => c.sha === sha("h"))).toMatchObject({
+                message: FOOTER_MESSAGE,
+                files: ["README.md"],
+            });
+        });
         it("counts first-parent commits", async () => {
             const count = (from, to) => git.countFirstParent(from === null ? null : sha(from), sha(to));
             expect(await count(null, "e")).toBe(5);