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

package/dist/plan.d.ts

@@ -1,111 +1,8 @@
-import type { AffectedDoc, AffectedOptions, AffectedReason } from "./affected.js";
-import type { Line } from "./branches.js";
-import type { PlanFacts } from "./facts.js";
-import type { BumpLevel, GitReader, ReadonlyFs, VersionScheme } from "./plugin.js";
+import type { PlanFacts } from "./model/facts-types.js";
+import type { Plan, PlanOptions, ResolveInput } from "./model/plan-types.js";
+import type { GitReader } from "./plugin.js";
 import type { UnitRelease } from "./release.js";
 import type { Workspace } from "./workspace.js";
-export interface PlanChange {
-    /** Absent for file-based changes. */
-    sha?: string;
-    type: string;
-    breaking: boolean;
-    scope?: string;
-    subject: string;
-    /** `BREAKING CHANGE` footer text. */
-    notes?: string;
-    pr?: number;
-    /** Absorbed unit the change came through. */
-    via?: string;
-    /** Release-As value of this commit for the unit. */
-    releaseAs?: string;
-}
-export interface UnitPlan {
-    id: string;
-    /** Unit root, `.` for the repo root. */
-    path: string;
-    plugin: string;
-    scheme: string;
-    tags: string[];
-    group: string | null;
-    affected: {
-        reason: AffectedReason;
-        via: string[];
-    } | null;
-    kind: "prerelease" | "rebuild" | "none";
-    baseTag: string | null;
-    lineBaseTag: string | null;
-    /** Null on a first release. */
-    from: string | null;
-    bump: BumpLevel | null;
-    releaseAs: string | null;
-    propagatedFrom: string[];
-    absorbedFrom: string[];
-    next: string | null;
-    version: string | null;
-    /** The planned commit. */
-    sha: string;
-    /** Core commit order. */
-    changes: PlanChange[];
-}
-export interface GroupPlan {
-    name: string;
-    members: string[];
-    baseTag: string | null;
-    from: string | null;
-    bump: BumpLevel | null;
-    next: string | null;
-    version: string | null;
-}
-export interface ReleasedUnit {
-    id: string;
-    path: string;
-    version: string;
-    tag: string;
-    floatingTags: string[];
-    releaseSha: string;
-    /** Not built from HEAD by this run (release sha differs from HEAD, or the unit is outside the build set). */
-    catchUp: boolean;
-    /** Null when not looked up (no forge, or a forge error in `plan`). */
-    forge: ReleasedForge | null;
-    line: "default" | "maintenance";
-    /** Highest stable version tagged for the unit, never on a maintenance line. */
-    latest: boolean;
-}
-export interface ReleasedForge {
-    /** PR that merged the release sha. */
-    pr: {
-        number: number;
-        url: string;
-    } | null;
-    /** Forge release of the tag. */
-    release: {
-        url: string;
-    } | null;
-}
-/** `tallyrelease plan --json`, schema 1. */
-export interface Plan extends Omit<AffectedDoc, "units"> {
-    line: Line | null;
-    /** Topological order, cycles by id. */
-    units: UnitPlan[];
-    /** Sorted by name. */
-    groups: GroupPlan[];
-    /** Stable releases in `(build.base, head]`; empty until filled. */
-    released: ReleasedUnit[];
-}
-export interface PlanOptions extends AffectedOptions {
-    /** Files at `head`, for intent source contexts. */
-    fs: ReadonlyFs;
-    /** Also list released units outside the build set with a pending release. */
-    all?: boolean;
-    debug?: (message: string) => void;
-}
-/** Inputs of `resolvePlan`, all collected before release math. */
-export interface ResolveInput {
-    affected: AffectedDoc;
-    facts: PlanFacts;
-    schemes: ReadonlyMap<string, VersionScheme<any>>;
-    all: boolean;
-}
 /** Release math over collected facts; no I/O. */
 export declare const resolvePlan: (workspace: Workspace, input: ResolveInput) => Plan;
 /** A plan with the facts it was resolved from. */
@@ -122,4 +19,3 @@ export declare const planWithFacts: (workspace: Workspace, git: GitReader, opts:
  * git and intent facts and resolves versions and kinds.
  */
 export declare const computePlan: (workspace: Workspace, git: GitReader, opts: PlanOptions) => Promise<Plan>;
-export type { Line as PlanLine } from "./branches.js";

package/dist/plan.js

@@ -1,9 +1,11 @@
 import { computeAffected } from "./affected.js";
 import { checkLimits, matchBranch } from "./branches.js";
+import { changeLevel, reach } from "./bump.js";
 import { coreCodes } from "./codes.js";
 import { collectPlanFacts } from "./facts.js";
 import { propagate } from "./propagate.js";
-import { changeLevel, footerOf, reach, releaseAsWarnings, releaseGroup, releaseUnit, unitIntent, } from "./release.js";
+import { releaseAsWarnings } from "./release-as.js";
+import { footerOf, releaseGroup, releaseUnit, unitIntent } from "./release.js";
 import { noMatchingTag } from "./tags.js";
 import { maxLevel } from "./util.js";
 import { validateRelease } from "./validate.js";

package/dist/release-as.d.ts

@@ -0,0 +1,33 @@
+import type { Warning } from "./errors.js";
+import type { AttributedChange, RangeFacts } from "./model/facts-types.js";
+import type { Unit, VersionScheme } from "./plugin.js";
+import type { From } from "./version-math.js";
+interface CommitValues {
+    sha?: string;
+    /** Qualified values for the unit, else plain values of an attributed commit. */
+    values: string[];
+}
+/** The Release-As footer value that applies to a unit. */
+export interface ReleaseAsWinner<V> {
+    readonly sha?: string;
+    /** As written in the footer. */
+    readonly raw: string;
+    readonly version: V;
+}
+/** Release-As values per commit for one unit, in range order. */
+export declare const commitValues: (id: string, changes: readonly AttributedChange[]) => CommitValues[];
+/** Newest valid value wins; invalid values and other values warn. */
+export declare const pickReleaseAs: <V>(input: {
+    unit: Unit;
+    scheme: VersionScheme<V>;
+    from: From<V> | undefined;
+    commits: readonly CommitValues[];
+}, warnings: Warning[]) => ReleaseAsWinner<V> | undefined;
+/** Normalized value of the first valid Release-As of a commit. */
+export declare const appliedValue: <V>(scheme: VersionScheme<V>, values: readonly string[]) => string | undefined;
+/**
+ * Warns for qualified Release-As values naming unknown or unreleased units and
+ * for plain values on commits attributed to no released unit.
+ */
+export declare const releaseAsWarnings: (units: readonly Unit[], ranges: readonly RangeFacts[]) => Warning[];
+export {};

package/dist/release-as.js

@@ -0,0 +1,101 @@
+import { coreCodes } from "./codes.js";
+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;
+};
+/** Release-As values per commit for one unit, in range order. */
+export 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,
+    }));
+};
+/** Newest valid value wins; invalid values and other values warn. */
+export 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(coreCodes.warning("W_RELEASE_AS_INVALID", `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(coreCodes.warning("W_RELEASE_AS_CONFLICT", `unit "${unit.id}": Release-As "${winner.raw}"${at(winner.sha)} wins over "${raw}"${at(sha)}`, { unit: unit.id }));
+            }
+        }
+    }
+    return winner;
+};
+/** Normalized value of the first valid Release-As of a commit. */
+export 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;
+};
+/**
+ * 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}`, coreCodes.warning(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()];
+};

package/dist/release-items.d.ts

@@ -1,6 +1,6 @@
 import type { ReleasePrMode } from "./config.js";
 import type { MarkerRelease } from "./marker.js";
-import type { Plan } from "./plan.js";
+import type { Plan } from "./model/plan-types.js";
 import type { Workspace } from "./workspace.js";
 /** A group or an ungrouped released unit; releases as one. */
 export interface ReleaseItem {

package/dist/release-settings.d.ts

@@ -0,0 +1,30 @@
+import type { ReleasePrMode, TallyConfig, VersionTemplate } from "./config.js";
+import type { BranchRule } from "./model/branch-types.js";
+import type { BumpLevel, Unit } from "./plugin.js";
+/** Release config with defaults applied. */
+export interface ReleaseSettings {
+    /** Commit type to level. */
+    readonly bumps: ReadonlyMap<string, BumpLevel>;
+    /** Levels used while `core(from).major == 0`. */
+    readonly preMajor: {
+        readonly breaking: BumpLevel;
+        readonly feat: BumpLevel;
+    };
+    /** Level cap of absorbed changes with a bump. */
+    readonly absorbed: "patch" | "minor";
+    /** In config order. */
+    readonly branches: readonly BranchRule[];
+    readonly releasePr: {
+        readonly default: ReleasePrMode;
+        /** Set by unit overlays, by unit id. */
+        readonly units: ReadonlyMap<string, ReleasePrMode>;
+        /** Set by groups, by group name. */
+        readonly groups: ReadonlyMap<string, ReleasePrMode>;
+    };
+    /** Floating tag formats. */
+    readonly floating: readonly string[];
+    /** Version file templates by unit id. */
+    readonly templates: ReadonlyMap<string, readonly VersionTemplate[]>;
+}
+/** Applies the defaults to `bumps` and `branches`. */
+export declare const releaseSettings: (config: TallyConfig, units: readonly Unit[]) => ReleaseSettings;

package/dist/release-settings.js

@@ -0,0 +1,38 @@
+import { normalizeRoot } from "./discover.js";
+const DEFAULT_TYPES = {
+    feat: "minor",
+    fix: "patch",
+    perf: "patch",
+    revert: "patch",
+};
+/** Unit overlays of the config with the id of the unit at their root. */
+const unitOverlays = (config, units) => Object.entries(config.units ?? {}).flatMap(([root, overlay]) => {
+    const unit = units.find((u) => u.root === normalizeRoot(root));
+    return unit ? [[unit.id, overlay]] : [];
+});
+/** Applies the defaults to `bumps` and `branches`. */
+export const releaseSettings = (config, units) => {
+    const overlays = unitOverlays(config, units);
+    return {
+        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,
+        })),
+        releasePr: {
+            default: config.defaults?.releasePr ?? "shared",
+            units: new Map(overlays.flatMap(([id, overlay]) => overlay.releasePr ? [[id, overlay.releasePr]] : [])),
+            groups: new Map(Object.entries(config.groups ?? {}).flatMap(([name, group]) => group.releasePr ? [[name, group.releasePr]] : [])),
+        },
+        floating: config.tags?.floating ?? [],
+        templates: new Map(overlays.flatMap(([id, overlay]) => overlay.versionFiles ? [[id, overlay.versionFiles]] : [])),
+    };
+};

package/dist/release.d.ts

@@ -1,63 +1,9 @@
-import type { ReleasePrMode, TallyConfig, VersionTemplate } from "./config.js";
+import type { UnitChange } from "./bump.js";
 import type { Warning } from "./errors.js";
-import type { GroupFacts, RangeFacts, UnitFacts } from "./facts.js";
-import type { BumpLevel, Change, Unit, VersionScheme } from "./plugin.js";
-/**
- * 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).
- */
-declare const changeLevel: ({ change, via }: UnitChange, settings: ReleaseSettings, preMajor: boolean) => BumpLevel | null;
-/** The Release-As footer value that applies to a unit. */
-export interface ReleaseAsWinner<V> {
-    readonly sha?: string;
-    /** As written in the footer. */
-    readonly raw: string;
-    readonly version: V;
-}
-/** A normalized branch rule. */
-export interface BranchRule {
-    readonly name: string;
-    readonly line: "default" | "maintenance";
-    readonly channel: string | null;
-    /** Release item of the absolute maintenance check. */
-    readonly unit: string | null;
-    readonly group: string | null;
-}
-/** Release config with defaults applied. */
-export interface ReleaseSettings {
-    /** Commit type to level. */
-    readonly bumps: ReadonlyMap<string, BumpLevel>;
-    /** Levels used while `core(from).major == 0`. */
-    readonly preMajor: {
-        readonly breaking: BumpLevel;
-        readonly feat: BumpLevel;
-    };
-    /** Level cap of absorbed changes with a bump. */
-    readonly absorbed: "patch" | "minor";
-    /** In config order. */
-    readonly branches: readonly BranchRule[];
-    readonly releasePr: {
-        readonly default: ReleasePrMode;
-        /** Set by unit overlays, by unit id. */
-        readonly units: ReadonlyMap<string, ReleasePrMode>;
-        /** Set by groups, by group name. */
-        readonly groups: ReadonlyMap<string, ReleasePrMode>;
-    };
-    /** Floating tag formats. */
-    readonly floating: readonly string[];
-    /** Version file templates by unit id. */
-    readonly templates: ReadonlyMap<string, readonly VersionTemplate[]>;
-}
-/**
- * A Change of a released unit; `via` names the first absorbed unit (by id) a
- * change not attributed to the unit came through.
- */
-export interface UnitChange {
-    readonly change: Change;
-    readonly via?: string;
-}
+import type { GroupFacts, RangeFacts, UnitFacts } from "./model/facts-types.js";
+import type { BumpLevel, Unit, VersionScheme } from "./plugin.js";
+import type { ReleaseAsWinner } from "./release-as.js";
+import type { ReleaseSettings } from "./release-settings.js";
 /** Bump inputs of a released unit, before propagation. */
 export interface UnitIntent<V> {
     /** Own and absorbed level. */
@@ -98,18 +44,6 @@ export interface ReleaseInput<V> {
     readonly head: string;
     readonly channel: string | null;
 }
-/**
- * Unreleased units reachable over `id`'s dependencies, never stepping into or
- * through a released unit.
- */
-export declare const reach: (id: string, dependencies: ReadonlyMap<string, readonly string[]>, released: ReadonlySet<string>) => Set<string>;
-/** Applies the defaults to `bumps` and `branches`. */
-export declare const releaseSettings: (config: TallyConfig, units: readonly Unit[]) => ReleaseSettings;
-/**
- * Warns for qualified Release-As values naming unknown or unreleased units and
- * for plain values on commits attributed to no released unit.
- */
-export declare const releaseAsWarnings: (units: readonly Unit[], ranges: readonly RangeFacts[]) => Warning[];
 /**
  * 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
@@ -141,4 +75,3 @@ export interface GroupMember<V> {
  * counter, max total.
  */
 export declare const releaseGroup: <V>(group: GroupFacts, members: readonly GroupMember<V>[], warnings: Warning[]) => Omit<UnitRelease, "releaseAsFooter">;
-export { changeLevel };