@tallyrelease/core 0.5.0-beta.39 → 0.5.0-beta.44

package/README.md

@@ -40,7 +40,7 @@ renderTag({ id: "web", tagFormat: "{id}-v{version}" }, "1.2.0"); // "web-v1.2.0"
 
 ## Testing
 
-The `@tallyrelease/core/testing` export provides in-memory fakes: `memoryFs`, `memoryCtx` and `memoryGit`. The `@tallyrelease/core/testing/conformance` export provides `gitReaderConformance`, a shared `GitReader` spec that requires vitest.
+The `@tallyrelease/core/testing` export provides in-memory fakes: `memoryFs`, `memoryCtx` and `memoryGit`. The `@tallyrelease/core/testing/conformance` export provides `gitReaderConformance` and `schemeConformance`, shared `GitReader` and `VersionScheme` specs that require vitest.
 
 ## Licence
 

package/dist/testing/conformance.d.ts

@@ -1,5 +1,5 @@
 import type { Dag } from "./index.js";
-import type { GitReader, MaybePromise } from "../plugin.js";
+import type { GitReader, MaybePromise, VersionScheme } from "../plugin.js";
 /** Builds a reader for `dag`; `sha` maps a commit id to the reader's sha. */
 export type ReaderFactory = (dag: Dag) => MaybePromise<{
     git: GitReader;
@@ -13,3 +13,9 @@ export type ReaderFactory = (dag: Dag) => MaybePromise<{
  * `introduced` runs on its own fixture.
  */
 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.
+ */
+export declare const schemeConformance: <V>(scheme: VersionScheme<V>) => void;

package/dist/testing/conformance.js

@@ -202,3 +202,94 @@ export const gitReaderConformance = (makeReader) => {
         });
     });
 };
+const LEVELS = ["major", "minor", "patch"];
+const PRE_CTX = {
+    unit: {
+        id: "u",
+        root: ".",
+        plugin: "conformance",
+        include: [],
+        exclude: [],
+        version: "tag",
+        scheme: "conformance",
+        tagFormat: "v{version}",
+        propagate: "auto",
+        tags: [],
+        initialVersion: null,
+        meta: {},
+    },
+    head: "0".repeat(40),
+    baseTag: null,
+    tags: [],
+    firstParent: { sinceLineBase: 3, total: 7 },
+    channel: "rc",
+};
+/**
+ * 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.
+ */
+export const schemeConformance = (scheme) => {
+    describe("VersionScheme conformance", () => {
+        const initial = scheme.initial();
+        const bumped = (level) => scheme.bump(initial, level);
+        it("round-trips parse and format", () => {
+            for (const v of [initial, ...LEVELS.map(bumped)]) {
+                const raw = scheme.format(v);
+                const parsed = scheme.parse(raw);
+                expect(parsed).toBeDefined();
+                expect(scheme.format(parsed)).toBe(raw);
+                expect(scheme.compare(parsed, v)).toBe(0);
+            }
+        });
+        it("rejects input that is not a version", () => {
+            expect(scheme.parse("")).toBeUndefined();
+            expect(scheme.parse("not a version")).toBeUndefined();
+        });
+        it("compares consistently", () => {
+            const low = initial;
+            const high = bumped("patch");
+            expect(scheme.compare(low, low)).toBe(0);
+            expect(scheme.compare(low, high)).toBeLessThan(0);
+            expect(scheme.compare(high, low)).toBeGreaterThan(0);
+        });
+        it.each(LEVELS)("bumps %s above the previous version", (level) => {
+            const next = bumped(level);
+            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,
+            });
+            expect(scheme.core(bumped("minor"))).toEqual({
+                major,
+                minor: minor + 1,
+                patch: 0,
+            });
+            expect(scheme.core(bumped("patch"))).toEqual({
+                major,
+                minor,
+                patch: patch + 1,
+            });
+        });
+        it("keeps the core when releasing or prereleasing", () => {
+            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.d.ts

@@ -1,5 +1,4 @@
 import type { Ctx, GitReader, ReadonlyFs } from "../plugin.js";
-import type { ReaderFactory } from "./conformance.js";
 /** In-memory `ReadonlyFs` over a path-to-content map. */
 export declare const memoryFs: (files: Record<string, string>) => ReadonlyFs;
 export interface MemoryCtxOptions<O> {
@@ -43,6 +42,3 @@ export interface MemoryGit extends GitReader {
 }
 /** In-memory `GitReader` over a commit graph. */
 export declare const memoryGit: (dag: Dag) => MemoryGit;
-export type { ReaderFactory } from "./conformance.js";
-/** Re-export of `@tallyrelease/core/testing/conformance`; requires vitest. */
-export declare const gitReaderConformance: (makeReader: ReaderFactory) => void;

package/dist/testing/index.js

@@ -1,13 +1,5 @@
 import picomatch from "picomatch/posix.js";
 import { compare, uniqueSorted } from "../util.js";
-// Loaded optionally so the fakes work without vitest installed.
-// eslint-disable-next-line no-restricted-syntax
-const conformance = await import("./conformance.js").catch((error) => {
-    if (error.code === "ERR_MODULE_NOT_FOUND") {
-        return null;
-    }
-    throw error;
-});
 const SKIPPED = new Set([".git", "node_modules"]);
 const changed = (a, b) => uniqueSorted([...a.keys(), ...b.keys()]).filter((p) => a.get(p) !== b.get(p));
 /** In-memory `ReadonlyFs` over a path-to-content map. */
@@ -149,10 +141,3 @@ export const memoryGit = (dag) => {
         parents: (ref) => [...node(ref).parents],
     };
 };
-/** Re-export of `@tallyrelease/core/testing/conformance`; requires vitest. */
-export const gitReaderConformance = (makeReader) => {
-    if (conformance === null) {
-        throw new Error("gitReaderConformance requires vitest");
-    }
-    conformance.gitReaderConformance(makeReader);
-};

package/package.json

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