@tallyrelease/core 0.5.0-beta.52 → 0.5.0-beta.56

package/dist/builtin.js

@@ -1,3 +1,4 @@
+import { calver } from "./calver.js";
 import { conventionalCommits } from "./conventional.js";
 import { PLUGIN_API_VERSION } from "./plugin.js";
 import { semver } from "./semver.js";
@@ -7,6 +8,6 @@ export const CORE_PLUGIN = "core";
 export const corePlugin = {
     apiVersion: PLUGIN_API_VERSION,
     name: CORE_PLUGIN,
-    schemes: { semver },
+    schemes: { semver, calver },
     intent: [conventionalCommits],
 };

package/dist/calver.d.ts

@@ -0,0 +1,8 @@
+import type { VersionScheme } from "./plugin.js";
+import type { SemVer } from "./semver.js";
+/**
+ * Calendar versions `Y.M.N` with SemVer syntax: every bump increments `N`,
+ * releasing moves to `Y.M.0` of the planned commit's UTC date when that
+ * month is newer.
+ */
+export declare const calver: VersionScheme<SemVer>;

package/dist/calver.js

@@ -0,0 +1,37 @@
+import { semver } from "./semver.js";
+/** Year and month of `ctx.date` in UTC. */
+const monthOf = (ctx) => {
+    if (ctx.date === undefined) {
+        throw new Error("calver needs the commit date; the git reader does not provide commitDate");
+    }
+    const date = Date.parse(ctx.date);
+    if (Number.isNaN(date)) {
+        throw new Error(`calver cannot parse the commit date "${ctx.date}"`);
+    }
+    const utc = new Date(date);
+    return { year: utc.getUTCFullYear(), month: utc.getUTCMonth() + 1 };
+};
+/** `next`, or `Y.M.0` of the commit date when that month is newer. */
+const release = (next, ctx) => {
+    const { year, month } = monthOf(ctx);
+    const newer = year > next.major || (year === next.major && month > next.minor);
+    return newer
+        ? { major: year, minor: month, patch: 0, prerelease: [], build: [] }
+        : next;
+};
+/**
+ * Calendar versions `Y.M.N` with SemVer syntax: every bump increments `N`,
+ * releasing moves to `Y.M.0` of the planned commit's UTC date when that
+ * month is newer.
+ */
+export const calver = {
+    ...semver,
+    parse: (raw) => {
+        const v = semver.parse(raw);
+        return v && v.build.length === 0 ? v : undefined;
+    },
+    initial: () => ({ major: 0, minor: 0, patch: 0, prerelease: [], build: [] }),
+    bump: (v) => semver.bump(v, "patch"),
+    release,
+    prerelease: (next, ctx) => semver.prerelease(release(next, ctx), ctx),
+};

package/dist/codes.js

@@ -94,7 +94,7 @@ export const coreCodes = defineCodes({
         fix: "Fix the options named in the message, or remove them.",
     },
     E_PLUGIN_UNKNOWN: {
-        cause: "`plugins` lists a name that matches no built-in plugin (`node`, `php`, `kustomize`).",
+        cause: "`plugins` lists a name that matches no built-in plugin (`node`, `php`, `kustomize`, `dart`).",
         fix: "Correct the plugin name in `plugins`, or remove the entry.",
     },
     E_RELEASE_ITEM_NAME: {

package/dist/facts.js

@@ -234,6 +234,7 @@ export const rangeFacts = (workspace, git, opts) => {
 /** Runs every `GitReader` and intent source call a plan needs. */
 export const collectPlanFacts = async (workspace, git, opts) => {
     const { head } = opts;
+    const date = await git.commitDate?.(head);
     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);
@@ -278,5 +279,13 @@ export const collectPlanFacts = async (workspace, git, opts) => {
             }))),
         });
     }
-    return { head, units, ranges: all(), groups, tagNames, warnings };
+    return {
+        head,
+        ...(date === undefined ? {} : { date }),
+        units,
+        ranges: all(),
+        groups,
+        tagNames,
+        warnings,
+    };
 };

package/dist/flutter.d.ts

@@ -0,0 +1,14 @@
+import type { VersionScheme } from "./plugin.js";
+/** A parsed flutter version `x.y.z+build`. */
+export interface FlutterVersion {
+    major: number;
+    minor: number;
+    patch: number;
+    build: number;
+}
+/**
+ * Flutter `x.y.z+build` scheme. The build number is the larger of the
+ * first-parent total plus the owning plugin's `buildOffset` meta and the
+ * highest tagged build plus one.
+ */
+export declare const flutter: VersionScheme<FlutterVersion>;

package/dist/flutter.js

@@ -0,0 +1,48 @@
+const RE = /^(\d+)\.(\d+)\.(\d+)\+(\d+)$/u;
+/** A version at the end of a tag name. */
+const TAG_VERSION = /\d+\.\d+\.\d+\+\d+$/u;
+const bumpCore = (v, level) => {
+    switch (level) {
+        case "major":
+            return { ...v, major: v.major + 1, minor: 0, patch: 0 };
+        case "minor":
+            return { ...v, minor: v.minor + 1, patch: 0 };
+        case "patch":
+            return { ...v, patch: v.patch + 1 };
+    }
+};
+const parse = (raw) => {
+    const m = RE.exec(raw);
+    return m
+        ? {
+            major: Number(m[1]),
+            minor: Number(m[2]),
+            patch: Number(m[3]),
+            build: Number(m[4]),
+        }
+        : undefined;
+};
+const buildNo = (ctx) => {
+    const tagged = ctx.tags.map((t) => parse(TAG_VERSION.exec(t)?.[0] ?? "")?.build ?? 0);
+    const offset = Number(ctx.unit.meta[ctx.unit.plugin]?.["buildOffset"] ?? 0);
+    return Math.max(ctx.firstParent.total + offset, Math.max(0, ...tagged) + 1);
+};
+/**
+ * Flutter `x.y.z+build` scheme. The build number is the larger of the
+ * first-parent total plus the owning plugin's `buildOffset` meta and the
+ * highest tagged build plus one.
+ */
+export const flutter = {
+    parse,
+    format: (v) => `${[v.major, v.minor, v.patch].join(".")}+${String(v.build)}`,
+    compare: (a, b) => a.major - b.major ||
+        a.minor - b.minor ||
+        a.patch - b.patch ||
+        a.build - b.build,
+    core: ({ major, minor, patch }) => ({ major, minor, patch }),
+    isPrerelease: () => false,
+    initial: () => ({ major: 0, minor: 1, patch: 0, build: 0 }),
+    bump: (v, level) => bumpCore(v, level),
+    release: (next, ctx) => ({ ...next, build: buildNo(ctx) }),
+    prerelease: (next, ctx) => ({ ...next, build: buildNo(ctx) }),
+};

package/dist/index.d.ts

@@ -14,10 +14,12 @@ export type { BumpLevel, Change, Ctx, Edge, EdgeDraft, GitReader, IntentSource,
 export type { Marker, MarkerRelease } from "./marker.js";
 export type { ReleaseItem } from "./release-items.js";
 export type { ReleaseSettings } from "./release-settings.js";
+export type { FlutterVersion } from "./flutter.js";
 export type { SemVer } from "./semver.js";
 export type { TagFormat } from "./tags.js";
 export type { IntentEntry, Workspace, WorkspaceInput } from "./workspace.js";
 export { computeAffected } from "./affected.js";
+export { calver } from "./calver.js";
 export { maintenanceCut } from "./branches.js";
 export { releaseNotes } from "./changelog.js";
 export { coreCodes, defineCodes } from "./codes.js";
@@ -25,6 +27,7 @@ export { CONFIG_FILE } from "./config.js";
 export { parseCommit } from "./conventional.js";
 export { TallyError } from "./errors.js";
 export { explainUnit } from "./explain.js";
+export { flutter } from "./flutter.js";
 export { definePlugin, defaultUnitId, PLUGIN_API_VERSION } from "./plugin.js";
 export { computePlan } from "./plan.js";
 export { decodeMarker, encodeMarker } from "./marker.js";

package/dist/index.js

@@ -1,6 +1,7 @@
 /** @deprecated Unused, will be removed in 1.0. */
 export const version = "0.0.0";
 export { computeAffected } from "./affected.js";
+export { calver } from "./calver.js";
 export { maintenanceCut } from "./branches.js";
 export { releaseNotes } from "./changelog.js";
 export { coreCodes, defineCodes } from "./codes.js";
@@ -8,6 +9,7 @@ export { CONFIG_FILE } from "./config.js";
 export { parseCommit } from "./conventional.js";
 export { TallyError } from "./errors.js";
 export { explainUnit } from "./explain.js";
+export { flutter } from "./flutter.js";
 export { definePlugin, defaultUnitId, PLUGIN_API_VERSION } from "./plugin.js";
 export { computePlan } from "./plan.js";
 export { decodeMarker, encodeMarker } from "./marker.js";

package/dist/model/facts-types.d.ts

@@ -70,6 +70,8 @@ export interface GroupFacts {
 /** Git and intent data of every released unit, collected before release math. */
 export interface PlanFacts {
     readonly head: string;
+    /** Committer date of `head`; set when the git reader has `commitDate`. */
+    readonly date?: string;
     /** Released units, sorted by id. */
     readonly units: readonly UnitFacts[];
     /** One entry per distinct base tag commit. */

package/dist/plan.js

@@ -61,6 +61,7 @@ const releaseInputs = (workspace, { facts, schemes }, channel) => {
             range,
             absorbed: reach(unit.id, workspace.graph.dependencies, released),
             head: facts.head,
+            ...(facts.date === undefined ? {} : { date: facts.date }),
             channel,
         },
     ]));

package/dist/plugin.d.ts

@@ -74,6 +74,8 @@ export interface GitReader {
      * `path`; null if none.
      */
     introduced: (path: string, to: string) => MaybePromise<string | null>;
+    /** Committer date of `ref`, ISO 8601. */
+    commitDate?: (ref: string) => MaybePromise<string>;
 }
 export interface TagRef {
     name: string;
@@ -174,6 +176,8 @@ export interface PreCtx {
     /** Full sha of the planned commit. */
     head: string;
     baseTag: string | null;
+    /** Committer date of `head`, ISO 8601; set when the git reader has `commitDate`. */
+    date?: string;
     /** All tags of this unit, reachable or not, scheme-sorted. */
     tags: readonly string[];
     firstParent: {

package/dist/release.d.ts

@@ -42,6 +42,8 @@ export interface ReleaseInput<V> {
     /** Unreleased units absorbed by the unit (`reach`). */
     readonly absorbed: ReadonlySet<string>;
     readonly head: string;
+    /** Committer date of `head`. */
+    readonly date?: string;
     readonly channel: string | null;
 }
 /**

package/dist/release.js

@@ -43,8 +43,12 @@ export const releaseUnit = (input, intent, warnings) => {
     const from = fromOf(scheme, facts);
     const initial = initialOf(unit, scheme);
     const bumped = bumpedOf(scheme, bump, { from, initial });
+    const ctx = ctxOf(unit, input, {
+        ...facts,
+        tags: facts.tags.map((t) => t.name),
+    });
     if (from === undefined && releaseAs === undefined && bumped !== undefined) {
-        warnings.push(...initialBelowPrerelease(scheme, initial, facts));
+        warnings.push(...initialBelowPrerelease(scheme, scheme.release(initial, ctx), facts));
     }
     const raw = releaseAs ?? bumped;
     return {
@@ -59,15 +63,7 @@ export const releaseUnit = (input, intent, warnings) => {
                 : from === undefined
                     ? "initial"
                     : "bump",
-        ...render({
-            scheme,
-            raw,
-            ctx: ctxOf(unit, input.head, {
-                ...facts,
-                tags: facts.tags.map((t) => t.name),
-            }),
-            channel: input.channel,
-        }),
+        ...render({ scheme, raw, ctx, channel: input.channel }),
     };
 };
 /**
@@ -82,18 +78,13 @@ export const releaseGroup = (group, members, warnings) => {
     if (!first) {
         throw new TypeError("a group has at least one member");
     }
-    const { scheme, facts, channel, head } = first.input;
+    const { scheme, facts, channel } = 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) => {
@@ -102,6 +93,18 @@ export const releaseGroup = (group, members, warnings) => {
     })
         .sort((a, b) => scheme.compare(a.version, b.version) || compare(a.name, b.name))
         .map((t) => t.name);
+    const ctx = ctxOf(first.input.unit, first.input, {
+        baseTag: group.baseTag,
+        tags,
+        sinceLineBase: group.sinceLineBase,
+        total: Math.max(...members.map((m) => m.input.facts.total)),
+    });
+    if (from === undefined && releaseAs === undefined && bumped !== undefined) {
+        const released = scheme.release(initial, ctx);
+        for (const m of members) {
+            warnings.push(...initialBelowPrerelease(scheme, released, m.input.facts));
+        }
+    }
     const raw = max(bumped, releaseAs);
     const byReleaseAs = releaseAs !== undefined &&
         (bumped === undefined || scheme.compare(releaseAs, bumped) > 0);
@@ -116,16 +119,6 @@ export const releaseGroup = (group, members, warnings) => {
                 : 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,
-        }),
+        ...render({ scheme, raw, ctx, channel }),
     };
 };

package/dist/testing/conformance.d.ts

@@ -16,6 +16,9 @@ export declare const gitReaderConformance: (makeReader: ReaderFactory) => void;
 /**
  * Shared `VersionScheme` spec. Versions are derived from `initial()`:
  * `parse`/`format` round-trip, `compare` order, `bump` monotonicity per level,
- * and `release`/`prerelease` keeping the core triple.
+ * and `release`/`prerelease` keeping the core triple. With `dateDriven` the
+ * level order, the core reset and the core-keeping checks are skipped.
  */
-export declare const schemeConformance: <V>(scheme: VersionScheme<V>) => void;
+export declare const schemeConformance: <V>(scheme: VersionScheme<V>, { dateDriven }?: {
+    dateDriven?: boolean;
+}) => void;

package/dist/testing/conformance.js

@@ -133,6 +133,18 @@ 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("reads the committer date of a commit when supported", async () => {
+            if (git.commitDate === undefined) {
+                return;
+            }
+            const commits = await git.log(null, sha("e"));
+            for (const id of ["a", "e"]) {
+                // eslint-disable-next-line no-await-in-loop -- one commit at a time
+                const date = await git.commitDate(sha(id));
+                expect(date).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/u);
+                expect(date).toBe(commits.find((c) => c.sha === sha(id))?.date);
+            }
+        });
         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]));
@@ -219,6 +231,7 @@ const PRE_CTX = {
         meta: {},
     },
     head: "0".repeat(40),
+    date: "2024-01-01T00:00:00Z",
     baseTag: null,
     tags: [],
     firstParent: { sinceLineBase: 3, total: 7 },
@@ -227,9 +240,10 @@ const PRE_CTX = {
 /**
  * Shared `VersionScheme` spec. Versions are derived from `initial()`:
  * `parse`/`format` round-trip, `compare` order, `bump` monotonicity per level,
- * and `release`/`prerelease` keeping the core triple.
+ * and `release`/`prerelease` keeping the core triple. With `dateDriven` the
+ * level order, the core reset and the core-keeping checks are skipped.
  */
-export const schemeConformance = (scheme) => {
+export const schemeConformance = (scheme, { dateDriven = false } = {}) => {
     describe("VersionScheme conformance", () => {
         const initial = scheme.initial();
         const bumped = (level) => scheme.bump(initial, level);
@@ -258,35 +272,41 @@ export const schemeConformance = (scheme) => {
             expect(scheme.compare(next, initial)).toBeGreaterThan(0);
             expect(scheme.isPrerelease(next)).toBe(false);
         });
-        it("orders bump levels major > minor > patch", () => {
-            const [major, minor, patch] = LEVELS.map(bumped);
-            expect(scheme.compare(major, minor)).toBeGreaterThan(0);
-            expect(scheme.compare(minor, patch)).toBeGreaterThan(0);
-        });
-        it("resets lower core parts on a bump", () => {
-            const { major, minor, patch } = scheme.core(initial);
-            expect(scheme.core(bumped("major"))).toEqual({
-                major: major + 1,
-                minor: 0,
-                patch: 0,
+        // A date-driven scheme takes the core from the commit date.
+        if (!dateDriven) {
+            it("orders bump levels major > minor > patch", () => {
+                const [major, minor, patch] = LEVELS.map(bumped);
+                expect(scheme.compare(major, minor)).toBeGreaterThan(0);
+                expect(scheme.compare(minor, patch)).toBeGreaterThan(0);
             });
-            expect(scheme.core(bumped("minor"))).toEqual({
-                major,
-                minor: minor + 1,
-                patch: 0,
+            it("resets lower core parts on a bump", () => {
+                const { major, minor, patch } = scheme.core(initial);
+                expect(scheme.core(bumped("major"))).toEqual({
+                    major: major + 1,
+                    minor: 0,
+                    patch: 0,
+                });
+                expect(scheme.core(bumped("minor"))).toEqual({
+                    major,
+                    minor: minor + 1,
+                    patch: 0,
+                });
+                expect(scheme.core(bumped("patch"))).toEqual({
+                    major,
+                    minor,
+                    patch: patch + 1,
+                });
             });
-            expect(scheme.core(bumped("patch"))).toEqual({
-                major,
-                minor,
-                patch: patch + 1,
+            it("keeps the core when releasing or prereleasing", () => {
+                const next = bumped("minor");
+                expect(scheme.core(scheme.release(next, PRE_CTX))).toEqual(scheme.core(next));
+                expect(scheme.core(scheme.prerelease(next, PRE_CTX))).toEqual(scheme.core(next));
             });
-        });
-        it("keeps the core when releasing or prereleasing", () => {
+        }
+        it("orders a prerelease at or below its release", () => {
             const next = bumped("minor");
             const release = scheme.release(next, PRE_CTX);
             const pre = scheme.prerelease(next, PRE_CTX);
-            expect(scheme.core(release)).toEqual(scheme.core(next));
-            expect(scheme.core(pre)).toEqual(scheme.core(next));
             expect(scheme.isPrerelease(release)).toBe(false);
             expect(scheme.compare(pre, release)).toBeLessThanOrEqual(0);
             expect(scheme.parse(scheme.format(pre))).toBeDefined();

package/dist/testing/index.js

@@ -137,6 +137,7 @@ export const memoryGit = (dag) => {
                 .find((n) => changed(n.parents[0] === undefined ? new Map() : node(n.parents[0]).tree, n.tree).some(under));
             return intro?.id ?? null;
         },
+        commitDate: (ref) => node(ref).date,
         tree: (ref) => Object.fromEntries(node(ref).tree),
         parents: (ref) => [...node(ref).parents],
     };

package/dist/version-math.d.ts

@@ -14,7 +14,10 @@ export declare const bumpedOf: <V>(scheme: VersionScheme<V>, bump: BumpLevel | n
     from: From<V> | undefined;
     initial: V;
 }) => V | undefined;
-export declare const ctxOf: (unit: Unit, head: string, at: {
+export declare const ctxOf: (unit: Unit, { head, date }: {
+    head: string;
+    date?: string;
+}, at: {
     baseTag: {
         name: string;
     } | null;

package/dist/version-math.js

@@ -21,9 +21,10 @@ export const bumpedOf = (scheme, bump, { from, initial }) => bump === null
     : from === undefined
         ? initial
         : scheme.bump(from.version, bump);
-export const ctxOf = (unit, head, at) => ({
+export const ctxOf = (unit, { head, date }, at) => ({
     unit,
     head,
+    ...(date === undefined ? {} : { date }),
     baseTag: at.baseTag?.name ?? null,
     tags: at.tags,
     firstParent: { sinceLineBase: at.sinceLineBase, total: at.total },

package/package.json

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