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

package/dist/release.js

@@ -1,246 +1,7 @@
-import { coreCodes } from "./codes.js";
-import { normalizeRoot } from "./discover.js";
+import { ownBump, unitChanges } from "./bump.js";
+import { appliedValue, commitValues, pickReleaseAs } from "./release-as.js";
 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(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;
-};
-/**
- * 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
-        ? []
-        : [
-            coreCodes.warning("W_INITIAL_BELOW_PRERELEASE", `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, units) => ({
-    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(Object.entries(config.units ?? {}).flatMap(([root, overlay]) => {
-            const unit = units.find((u) => u.root === normalizeRoot(root));
-            return unit && overlay.releasePr
-                ? [[unit.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(Object.entries(config.units ?? {}).flatMap(([root, overlay]) => {
-        const unit = units.find((u) => u.root === normalizeRoot(root));
-        return unit && overlay.versionFiles
-            ? [[unit.id, overlay.versionFiles]]
-            : [];
-    })),
-});
-/**
- * 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()];
-};
+import { bumpedOf, ctxOf, fromOf, initialBelowPrerelease, initialOf, render, } from "./version-math.js";
 /**
  * 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
@@ -368,4 +129,3 @@ export const releaseGroup = (group, members, warnings) => {
         }),
     };
 };
-export { changeLevel };

package/dist/released.d.ts

@@ -1,4 +1,4 @@
-import type { Plan, ReleasedUnit } from "./plan.js";
+import type { Plan, ReleasedUnit } from "./model/plan-types.js";
 import type { GitReader } from "./plugin.js";
 import type { Workspace } from "./workspace.js";
 /**

package/dist/version-files.d.ts

@@ -1,5 +1,5 @@
 import type { Warning } from "./errors.js";
-import type { Plan } from "./plan.js";
+import type { Plan } from "./model/plan-types.js";
 import type { ReadonlyFs, VersionFile } from "./plugin.js";
 import type { ReleaseItem } from "./release-items.js";
 import type { Workspace } from "./workspace.js";

package/dist/version-math.d.ts

@@ -0,0 +1,36 @@
+import type { Warning } from "./errors.js";
+import type { UnitFacts } from "./model/facts-types.js";
+import type { BumpLevel, PreCtx, Unit, VersionScheme } from "./plugin.js";
+/** A parsed `from` version; `label` names it in warnings. */
+export interface From<V> {
+    readonly version: V;
+    readonly label: string;
+}
+/** The `from` version of a unit, from `facts.fromTag`. */
+export declare const fromOf: <V>(scheme: VersionScheme<V>, facts: UnitFacts) => From<V> | undefined;
+export declare const initialOf: <V>(unit: Unit, scheme: VersionScheme<V>) => V;
+/** `from` bumped by `bump`; the initial version on a first release. */
+export declare const bumpedOf: <V>(scheme: VersionScheme<V>, bump: BumpLevel | null, { from, initial }: {
+    from: From<V> | undefined;
+    initial: V;
+}) => V | undefined;
+export declare const ctxOf: (unit: Unit, head: string, at: {
+    baseTag: {
+        name: string;
+    } | null;
+    tags: readonly string[];
+    sinceLineBase: number;
+    total: number;
+}) => PreCtx;
+/** `next` and prerelease of `raw` under `ctx`. */
+export declare const render: <V>({ scheme, raw, ctx, channel, }: {
+    scheme: VersionScheme<V>;
+    raw: V | undefined;
+    ctx: PreCtx;
+    channel: string | null;
+}) => {
+    readonly next: string | null;
+    readonly prerelease: string | null;
+};
+/** Warns when a first release's initial version is not above the unit's highest prerelease tag. */
+export declare const initialBelowPrerelease: <V>(scheme: VersionScheme<V>, initial: V, facts: UnitFacts) => Warning[];

package/dist/version-math.js

@@ -0,0 +1,55 @@
+import { coreCodes } from "./codes.js";
+/** The `from` version of a unit, from `facts.fromTag`. */
+export 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})`,
+        };
+};
+export const initialOf = (unit, scheme) => (unit.initialVersion === null
+    ? undefined
+    : scheme.parse(unit.initialVersion)) ?? scheme.initial();
+/** `from` bumped by `bump`; the initial version on a first release. */
+export const bumpedOf = (scheme, bump, { from, initial }) => bump === null
+    ? undefined
+    : from === undefined
+        ? initial
+        : scheme.bump(from.version, bump);
+export const ctxOf = (unit, head, at) => ({
+    unit,
+    head,
+    baseTag: at.baseTag?.name ?? null,
+    tags: at.tags,
+    firstParent: { sinceLineBase: at.sinceLineBase, total: at.total },
+});
+/** `next` and prerelease of `raw` under `ctx`. */
+export 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 })),
+});
+/** Warns when a first release's initial version is not above the unit's highest prerelease tag. */
+export 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
+        ? []
+        : [
+            coreCodes.warning("W_INITIAL_BELOW_PRERELEASE", `unit "${facts.id}": initial version ${scheme.format(initial)} does not exceed prerelease tag "${highest.name}"`, { unit: facts.id }),
+        ];
+};

package/dist/workspace.d.ts

@@ -3,7 +3,7 @@ import type { Graph } from "./graph.js";
 import type { Group } from "./groups.js";
 import type { IntentSource, Unit, VersionFile } from "./plugin.js";
 import type { PluginEnv } from "./plugins.js";
-import type { ReleaseSettings } from "./release.js";
+import type { ReleaseSettings } from "./release-settings.js";
 import type { SchemeEntry } from "./schemes.js";
 /** An intent source with its plugin's validated options; callers build the `Ctx`. */
 export interface IntentEntry {

package/dist/workspace.js

@@ -4,7 +4,7 @@ import { discoverUnits } from "./discover.js";
 import { buildGraph } from "./graph.js";
 import { resolveGroups } from "./groups.js";
 import { activatePlugins, runHook } from "./plugins.js";
-import { releaseSettings } from "./release.js";
+import { releaseSettings } from "./release-settings.js";
 import { collectSchemes } from "./schemes.js";
 import { uniqueSorted } from "./util.js";
 const collectEdges = async (active, config, units) => {

package/package.json

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