@tallyrelease/core 0.5.0-beta.31 → 0.5.0-beta.33

package/dist/facts.d.ts

@@ -1,10 +1,45 @@
-import type { PlanFacts } from "./model/facts-types.js";
-import type { GitReader, ReadonlyFs } from "./plugin.js";
+import type { Warning } from "./errors.js";
+import type { GroupFacts, PlanFacts, RangeFacts } from "./model/facts-types.js";
+import type { GitReader, ReadonlyFs, VersionScheme } from "./plugin.js";
+import type { UnitTag } from "./tags.js";
 import type { Workspace } from "./workspace.js";
+type LineFacts = Awaited<ReturnType<typeof lineFacts>>;
+interface UnitBase {
+    scheme: VersionScheme<any>;
+    baseTag: UnitTag | null;
+    lineBaseTag: UnitTag | null;
+    introduced: string | null;
+    sinceLineBase: number;
+}
 export interface FactsOptions {
     head: string;
     fs: ReadonlyFs;
     debug?: (message: string) => void;
 }
+/** First-parent commit counters of `head`, memoized per commit. */
+export declare const lineFacts: (git: GitReader, head: string) => Promise<{
+    head: string;
+    total: number;
+    countSince: (sha: string) => Promise<number>;
+    lineCount: (root: string, lineBaseTag: UnitTag | null) => Promise<{
+        introduced: string | null;
+        sinceLineBase: number;
+    }>;
+}>;
+/** Tags of every unit and fixed group, relative to `head`. */
+export declare const tagFacts: (workspace: Workspace, git: GitReader, line: LineFacts) => Promise<{
+    tags: Map<string, import("./tags.js").UnitTags>;
+    bases: Map<string, UnitBase>;
+    groups: GroupFacts[];
+    isAncestor: (a: string, b: string) => Promise<boolean>;
+    tagNames: string[];
+}>;
+/** Attributed changes of `(from, head]`, memoized per `from`. */
+export declare const rangeFacts: (workspace: Workspace, git: GitReader, opts: FactsOptions) => {
+    range: (from: string | null) => Promise<RangeFacts>;
+    all: () => RangeFacts[];
+    warnings: Warning[];
+};
 /** Runs every `GitReader` and intent source call a plan needs. */
 export declare const collectPlanFacts: (workspace: Workspace, git: GitReader, opts: FactsOptions) => Promise<PlanFacts>;
+export {};

package/dist/facts.js

@@ -46,38 +46,9 @@ const dedupe = (changes) => {
     }
     return kept;
 };
-/** Runs every `GitReader` and intent source call a plan needs. */
-export const collectPlanFacts = async (workspace, git, opts) => {
-    const { head } = opts;
-    const warnings = [];
-    const ctx = pluginCtx({ ...opts, repo: { name: workspace.repo } }, warnings);
-    const intents = workspace.intents.map((entry) => ({
-        ...entry,
-        ctx: ctx(entry.plugin, entry.options),
-    }));
-    const schemes = schemeRegistry(workspace.schemes);
-    const allTags = await git.tags();
-    const tags = matchUnitTags(workspace.units, allTags, schemes);
-    const merged = new Set((await git.tagsMerged(head)).map((t) => t.name));
+/** First-parent commit counters of `head`, memoized per commit. */
+export const lineFacts = async (git, head) => {
     const total = await git.countFirstParent(null, head);
-    const ignored = matcher(workspace.ignore);
-    const isGlobal = matcher(workspace.globalInputs);
-    const owners = attribution(workspace.units);
-    const known = new Set(workspace.units.map((u) => u.id));
-    // File-less commits belong to every released unit (release-please parity).
-    const released = workspace.units
-        .filter((u) => u.version !== "none")
-        .map((u) => u.id);
-    const warned = new Set();
-    const warnUnknown = (plugin, changes) => {
-        for (const id of changes.flatMap((c) => c.units ?? [])) {
-            const key = `${plugin}\0${id}`;
-            if (!known.has(id) && !warned.has(key)) {
-                warned.add(key);
-                warnings.push(coreCodes.warning("W_UNIT_UNKNOWN", `intent names unknown unit "${id}"`, { plugin }));
-            }
-        }
-    };
     const counts = new Map();
     const countSince = async (sha) => {
         const cached = counts.get(sha);
@@ -88,42 +59,29 @@ export const collectPlanFacts = async (workspace, git, opts) => {
         counts.set(sha, count);
         return count;
     };
-    const ranges = new Map();
-    const range = async (from) => {
-        const cached = ranges.get(from);
-        if (cached) {
-            return cached;
-        }
-        const commits = Object.freeze([...(await git.log(from, head))].sort(byCommitOrder));
-        const position = new Map(commits.map((c, i) => [c.sha, i]));
-        const commitUnits = new Map(commits.map((c) => [
-            c.sha,
-            c.files.length === 0
-                ? released
-                : uniqueSorted(c.files
-                    .filter((f) => !ignored(f) && !isGlobal(f))
-                    .flatMap(owners)),
-        ]));
-        const changes = [];
-        for (const { plugin, source, ctx: sourceCtx } of intents) {
-            // eslint-disable-next-line no-await-in-loop -- hooks run sequentially in config order
-            const collected = await runHook(plugin, "intent", () => source.collect(sourceCtx, { from, to: head, commits }));
-            warnUnknown(plugin, collected);
-            changes.push(...collected);
+    /** Counter since the line base; without one, since the unit's introduction. */
+    const lineCount = async (root, lineBaseTag) => {
+        if (lineBaseTag) {
+            return {
+                introduced: null,
+                sinceLineBase: await countSince(lineBaseTag.sha),
+            };
         }
-        const attributed = dedupe(changes)
-            .map((change) => ({
-            change,
-            units: change.units
-                ? uniqueSorted(change.units.filter((id) => known.has(id)))
-                : (commitUnits.get(change.sha ?? "") ?? []),
-        }))
-            .sort((a, b) => (position.get(a.change.sha ?? "") ?? commits.length) -
-            (position.get(b.change.sha ?? "") ?? commits.length));
-        const result = { from, changes: attributed };
-        ranges.set(from, result);
-        return result;
+        const introduced = root === "." ? null : await git.introduced(root, head);
+        return {
+            introduced,
+            sinceLineBase: introduced === null ? total : (await countSince(introduced)) + 1,
+        };
     };
+    return { head, total, countSince, lineCount };
+};
+/** Tags of every unit and fixed group, relative to `head`. */
+export const tagFacts = async (workspace, git, line) => {
+    const { head } = line;
+    const schemes = schemeRegistry(workspace.schemes);
+    const allTags = await git.tags();
+    const tags = matchUnitTags(workspace.units, allTags, schemes);
+    const merged = new Set((await git.tagsMerged(head)).map((t) => t.name));
     const ancestry = new Map();
     const isAncestor = async (a, b) => {
         const key = `${a}\0${b}`;
@@ -152,20 +110,6 @@ export const collectPlanFacts = async (workspace, git, opts) => {
         }
         return a.sha !== b.sha && (await isAncestor(a.sha, b.sha)) ? b : a;
     };
-    /** Counter since the line base; without one, since the unit's introduction. */
-    const lineCount = async (root, lineBaseTag) => {
-        if (lineBaseTag) {
-            return {
-                introduced: null,
-                sinceLineBase: await countSince(lineBaseTag.sha),
-            };
-        }
-        const introduced = root === "." ? null : await git.introduced(root, head);
-        return {
-            introduced,
-            sinceLineBase: introduced === null ? total : (await countSince(introduced)) + 1,
-        };
-    };
     const bases = new Map();
     for (const unit of workspace.units) {
         const matched = tags.get(unit.id);
@@ -188,7 +132,7 @@ export const collectPlanFacts = async (workspace, git, opts) => {
             baseTag: stable.at(-1) ?? null,
             lineBaseTag,
             // eslint-disable-next-line no-await-in-loop -- one git call per unit
-            ...(await lineCount(unit.root, lineBaseTag)),
+            ...(await line.lineCount(unit.root, lineBaseTag)),
         });
     }
     const groups = [];
@@ -211,10 +155,89 @@ export const collectPlanFacts = async (workspace, git, opts) => {
             lineBaseTag,
             sinceLineBase: lineBaseTag
                 ? // eslint-disable-next-line no-await-in-loop -- memoized per line base
-                    await countSince(lineBaseTag.sha)
+                    await line.countSince(lineBaseTag.sha)
                 : Math.max(0, ...members.map((id) => bases.get(id)?.sinceLineBase ?? 0)),
         });
     }
+    return {
+        tags,
+        bases,
+        groups,
+        isAncestor,
+        tagNames: uniqueSorted(allTags.map((t) => t.name)),
+    };
+};
+/** Attributed changes of `(from, head]`, memoized per `from`. */
+export const rangeFacts = (workspace, git, opts) => {
+    const { head } = opts;
+    const warnings = [];
+    const ctx = pluginCtx({ ...opts, repo: { name: workspace.repo } }, warnings);
+    const intents = workspace.intents.map((entry) => ({
+        ...entry,
+        ctx: ctx(entry.plugin, entry.options),
+    }));
+    const ignored = matcher(workspace.ignore);
+    const isGlobal = matcher(workspace.globalInputs);
+    const owners = attribution(workspace.units);
+    const known = new Set(workspace.units.map((u) => u.id));
+    // File-less commits belong to every released unit (release-please parity).
+    const released = workspace.units
+        .filter((u) => u.version !== "none")
+        .map((u) => u.id);
+    const warned = new Set();
+    const warnUnknown = (plugin, changes) => {
+        for (const id of changes.flatMap((c) => c.units ?? [])) {
+            const key = `${plugin}\0${id}`;
+            if (!known.has(id) && !warned.has(key)) {
+                warned.add(key);
+                warnings.push(coreCodes.warning("W_UNIT_UNKNOWN", `intent names unknown unit "${id}"`, { plugin }));
+            }
+        }
+    };
+    const ranges = new Map();
+    const range = async (from) => {
+        const cached = ranges.get(from);
+        if (cached) {
+            return cached;
+        }
+        const commits = Object.freeze([...(await git.log(from, head))].sort(byCommitOrder));
+        const position = new Map(commits.map((c, i) => [c.sha, i]));
+        const commitUnits = new Map(commits.map((c) => [
+            c.sha,
+            c.files.length === 0
+                ? released
+                : uniqueSorted(c.files
+                    .filter((f) => !ignored(f) && !isGlobal(f))
+                    .flatMap(owners)),
+        ]));
+        const changes = [];
+        for (const { plugin, source, ctx: sourceCtx } of intents) {
+            // eslint-disable-next-line no-await-in-loop -- hooks run sequentially in config order
+            const collected = await runHook(plugin, "intent", () => source.collect(sourceCtx, { from, to: head, commits }));
+            warnUnknown(plugin, collected);
+            changes.push(...collected);
+        }
+        const attributed = dedupe(changes)
+            .map((change) => ({
+            change,
+            units: change.units
+                ? uniqueSorted(change.units.filter((id) => known.has(id)))
+                : (commitUnits.get(change.sha ?? "") ?? []),
+        }))
+            .sort((a, b) => (position.get(a.change.sha ?? "") ?? commits.length) -
+            (position.get(b.change.sha ?? "") ?? commits.length));
+        const result = { from, changes: attributed };
+        ranges.set(from, result);
+        return result;
+    };
+    return { range, all: () => [...ranges.values()], warnings };
+};
+/** Runs every `GitReader` and intent source call a plan needs. */
+export const collectPlanFacts = async (workspace, git, opts) => {
+    const { head } = opts;
+    const line = await lineFacts(git, head);
+    const { tags, bases, groups, isAncestor, tagNames } = await tagFacts(workspace, git, line);
+    const { range, all, warnings } = rangeFacts(workspace, git, opts);
     const groupOf = new Map(groups.flatMap((g) => g.members.map((id) => [id, g])));
     const units = [];
     for (const unit of workspace.units) {
@@ -246,7 +269,7 @@ export const collectPlanFacts = async (workspace, git, opts) => {
             lineBaseTag,
             introduced,
             sinceLineBase,
-            total,
+            total: line.total,
             changes: changes.filter((c) => c.units.includes(unit.id)),
             releaseAs: changes.flatMap(({ change }) => (change.releaseAs ?? [])
                 .filter((r) => r.unit === unit.id)
@@ -256,12 +279,5 @@ export const collectPlanFacts = async (workspace, git, opts) => {
             }))),
         });
     }
-    return {
-        head,
-        units,
-        ranges: [...ranges.values()],
-        groups,
-        tagNames: uniqueSorted(allTags.map((t) => t.name)),
-        warnings,
-    };
+    return { head, units, ranges: all(), groups, tagNames, warnings };
 };

package/dist/version-files.js

@@ -123,6 +123,64 @@ const templateFile = (file, unit) => {
     }
     return path;
 };
+const required = (staged, path, unit) => {
+    const content = staged.read(path);
+    if (content === undefined) {
+        throw coreCodes.error("E_VERSION_FILE_MISSING", `version file "${path}" of unit "${unit}" does not exist`, { path, unit });
+    }
+    return content;
+};
+/** Writes the plugin version files of the unit. */
+const versionFileStep = async (staged, step, pluginFiles) => {
+    const { workspace, item, unit, versions } = step;
+    const ctx = { unit, units: workspace.units, versions };
+    for (const file of pluginFiles) {
+        const content = required(staged, file.path, unit.id);
+        // eslint-disable-next-line no-await-in-loop -- files are written in order
+        const written = await runHook(unit.plugin, "write", () => file.write(content, item.version, ctx));
+        staged.files.set(file.path, written);
+    }
+};
+/** Rewrites the version templates of the unit; skips first releases. */
+const templateStep = (staged, step) => {
+    const { workspace, item, unit, scheme, from } = step;
+    const warnings = [];
+    const templates = from === null ? [] : (workspace.release.templates.get(unit.id) ?? []);
+    for (const template of templates) {
+        const { pattern } = template;
+        const file = templateFile(template.file, unit.id);
+        const result = applyTemplate(required(staged, file, unit.id), {
+            pattern,
+            unit: unit.id,
+            from: from ?? "",
+            next: item.version,
+            scheme,
+        });
+        staged.files.set(file, result.content);
+        if (!result.hit) {
+            warnings.push(coreCodes.warning("W_VERSION_FILE_NO_MATCH", `version file pattern "${pattern}" of unit "${unit.id}" matches nothing in "${file}"`, { unit: unit.id }));
+        }
+    }
+    return warnings;
+};
+/** Updates the unit's changelog; returns the new section, if any. */
+const changelogStep = (staged, step) => {
+    const { workspace, plan, unit, scheme, from, repoUrl, date, prUnits } = step;
+    const section = changelogSection(workspace, plan, {
+        id: unit.id,
+        repoUrl,
+        date,
+        prUnits,
+    });
+    if (section !== undefined) {
+        const path = changelogPath(unit);
+        staged.files.set(path, updateChangelog(staged.read(path), section, {
+            baseVersion: from,
+            scheme,
+        }));
+    }
+    return section;
+};
 /** Checks template files and patterns (`E_CONFIG`); runs no plugin hook. */
 export const validateTemplates = (workspace) => {
     for (const [id, templates] of workspace.release.templates) {
@@ -177,16 +235,12 @@ export const releaseFiles = async (workspace, plan, opts) => {
     const versions = new Map(items.flatMap((i) => i.units.map((id) => [id, i.version])));
     const pr = (item) => item.mode === "shared" ? "shared" : item.name;
     const files = new Map();
+    const staged = {
+        files,
+        read: (path) => files.get(path) ?? fs.read(path),
+    };
     const sections = new Map();
     const warnings = [];
-    const read = (path) => files.get(path) ?? fs.read(path);
-    const required = (path, unit) => {
-        const content = read(path);
-        if (content === undefined) {
-            throw coreCodes.error("E_VERSION_FILE_MISSING", `version file "${path}" of unit "${unit}" does not exist`, { path, unit });
-        }
-        return content;
-    };
     for (const item of items) {
         const prUnits = items
             .filter((i) => pr(i) === pr(item))
@@ -198,40 +252,24 @@ export const releaseFiles = async (workspace, plan, opts) => {
             if (!unit || !entry || !scheme) {
                 continue;
             }
-            const ctx = { unit, units: workspace.units, versions };
-            for (const file of pluginFiles.get(id) ?? []) {
-                const content = required(file.path, id);
-                // eslint-disable-next-line no-await-in-loop -- files are written in order
-                const written = await runHook(unit.plugin, "write", () => file.write(content, item.version, ctx));
-                files.set(file.path, written);
-            }
-            const { from } = entry;
-            const templates = from === null ? [] : (workspace.release.templates.get(id) ?? []);
-            for (const template of templates) {
-                const { pattern } = template;
-                const file = templateFile(template.file, id);
-                const result = applyTemplate(required(file, id), {
-                    pattern,
-                    unit: id,
-                    from: from ?? "",
-                    next: item.version,
-                    scheme,
-                });
-                files.set(file, result.content);
-                if (!result.hit) {
-                    warnings.push(coreCodes.warning("W_VERSION_FILE_NO_MATCH", `version file pattern "${pattern}" of unit "${id}" matches nothing in "${file}"`, { unit: id }));
-                }
-            }
-            const section = changelogSection(workspace, plan, {
-                id,
+            const step = {
+                workspace,
+                plan,
+                item,
+                unit,
+                scheme,
+                from: entry.from,
+                versions,
+                prUnits,
                 repoUrl,
                 date,
-                prUnits,
-            });
+            };
+            // eslint-disable-next-line no-await-in-loop -- files are written in order
+            await versionFileStep(staged, step, pluginFiles.get(id) ?? []);
+            warnings.push(...templateStep(staged, step));
+            const section = changelogStep(staged, step);
             if (section !== undefined) {
                 sections.set(id, section);
-                const path = changelogPath(unit);
-                files.set(path, updateChangelog(read(path), section, { baseVersion: from, scheme }));
             }
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tallyrelease/core",
-  "version": "0.5.0-beta.31",
+  "version": "0.5.0-beta.33",
   "description": "Pure planning core of tallyrelease",
   "repository": {
     "type": "git",