@tallyrelease/core 0.1.1-beta.1 → 0.2.0-beta.8

package/dist/util.d.ts

@@ -1,4 +1,7 @@
+import type { BumpLevel } from "./plugin.js";
 /** Code-unit string order, independent of locale. */
 export declare const compare: (a: string, b: string) => number;
 /** Sorted distinct values. */
 export declare const uniqueSorted: (values: Iterable<string>) => string[];
+/** The higher of two levels; null is lowest. */
+export declare const maxLevel: (a: BumpLevel | null, b: BumpLevel | null) => BumpLevel | null;

package/dist/util.js

@@ -1,4 +1,7 @@
+const LEVELS = ["patch", "minor", "major"];
 /** Code-unit string order, independent of locale. */
 export const compare = (a, b) => a < b ? -1 : a > b ? 1 : 0;
 /** Sorted distinct values. */
 export const uniqueSorted = (values) => [...new Set(values)].sort(compare);
+/** The higher of two levels; null is lowest. */
+export const maxLevel = (a, b) => a === null || (b !== null && LEVELS.indexOf(b) > LEVELS.indexOf(a)) ? b : a;

package/dist/validate.d.ts

@@ -0,0 +1,14 @@
+import type { Warning } from "./errors.js";
+import type { TagRef, VersionScheme } from "./plugin.js";
+import type { Workspace } from "./workspace.js";
+/**
+ * Release-only checks, never run by `affected`: scheme registry, schemes, tag
+ * formats and initial versions of released units, group members, branch rules,
+ * their absolute check targets and channels. Returns the scheme registry.
+ */
+export declare const validateRelease: (workspace: Workspace) => ReadonlyMap<string, VersionScheme<any>>;
+/**
+ * Checks `tags` against the released units: throws `E_TAG_FORMAT_OVERLAP`,
+ * returns `W_NO_MATCHING_TAG` warnings.
+ */
+export declare const validateTags: (workspace: Workspace, tags: readonly TagRef[]) => Warning[];

package/dist/validate.js

@@ -0,0 +1,67 @@
+import { validateBranches } from "./branches.js";
+import { TallyError } from "./errors.js";
+import { schemeRegistry } from "./schemes.js";
+import { compileTagFormat, matchUnitTags, noMatchingTag } from "./tags.js";
+import { uniqueSorted } from "./util.js";
+/**
+ * Release-only checks, never run by `affected`: scheme registry, schemes, tag
+ * formats and initial versions of released units, group members, branch rules,
+ * their absolute check targets and channels. Returns the scheme registry.
+ */
+export const validateRelease = (workspace) => {
+    const schemes = schemeRegistry(workspace.schemes);
+    for (const unit of workspace.units) {
+        if (unit.version === "none") {
+            continue;
+        }
+        const scheme = schemes.get(unit.scheme);
+        if (!scheme) {
+            throw new TallyError("E_SCHEME_UNKNOWN", `unit "${unit.id}" uses unknown scheme "${unit.scheme}"`, { unit: unit.id, scheme: unit.scheme });
+        }
+        compileTagFormat(unit.tagFormat, unit.id);
+        if (unit.initialVersion !== null &&
+            scheme.parse(unit.initialVersion) === undefined) {
+            throw new TallyError("E_INITIAL_VERSION", `initial version "${unit.initialVersion}" of unit "${unit.id}" is not a ${unit.scheme} version`, { unit: unit.id, version: unit.initialVersion });
+        }
+    }
+    const units = new Map(workspace.units.map((u) => [u.id, u]));
+    for (const { name, members } of workspace.groups) {
+        const unreleased = members.find((id) => units.get(id)?.version === "none");
+        if (unreleased !== undefined) {
+            throw new TallyError("E_GROUP_NOT_RELEASED", `group "${name}" names unit "${unreleased}", which is not released`, { group: name, unit: unreleased });
+        }
+        const schemeNames = uniqueSorted(members.map((id) => units.get(id)?.scheme ?? ""));
+        if (schemeNames.length > 1) {
+            throw new TallyError("E_GROUP_SCHEME", `members of group "${name}" use different schemes: ${schemeNames.join(", ")}`, { group: name, schemes: schemeNames });
+        }
+    }
+    validateBranches(workspace.release.branches);
+    const groupOf = new Map(workspace.groups.flatMap((g) => g.members.map((id) => [id, g.name])));
+    for (const rule of workspace.release.branches) {
+        const { unit, group } = rule;
+        const problem = unit !== null
+            ? units.get(unit)?.version === "none" || !units.has(unit)
+                ? `names unit "${unit}", which is not a released unit`
+                : groupOf.has(unit)
+                    ? `names unit "${unit}" of group "${groupOf.get(unit) ?? ""}"; use group`
+                    : undefined
+            : group !== null && !workspace.groups.some((g) => g.name === group)
+                ? `names unknown group "${group}"`
+                : undefined;
+        if (problem !== undefined) {
+            throw new TallyError("E_BRANCH_RULE", `branch rule "${rule.name}" ${problem}`, {
+                rule: rule.name,
+                ...(unit === null ? { group } : { unit }),
+            });
+        }
+    }
+    return schemes;
+};
+/**
+ * Checks `tags` against the released units: throws `E_TAG_FORMAT_OVERLAP`,
+ * returns `W_NO_MATCHING_TAG` warnings.
+ */
+export const validateTags = (workspace, tags) => {
+    const matched = matchUnitTags(workspace.units, tags, schemeRegistry(workspace.schemes));
+    return noMatchingTag(workspace.units, [...matched].map(([id, m]) => ({ id, tags: m.tags })), uniqueSorted(tags.map((t) => t.name)));
+};

package/dist/workspace.d.ts

@@ -1,7 +1,16 @@
 import type { Warning } from "./errors.js";
 import type { Graph } from "./graph.js";
-import type { Unit } from "./plugin.js";
+import type { Group } from "./groups.js";
+import type { IntentSource, Unit } from "./plugin.js";
 import type { PluginEnv } from "./plugins.js";
+import type { ReleaseSettings } from "./release.js";
+import type { SchemeEntry } from "./schemes.js";
+/** An intent source with its plugin's validated options; callers build the `Ctx`. */
+export interface IntentEntry {
+    readonly plugin: string;
+    readonly options: unknown;
+    readonly source: IntentSource;
+}
 export interface WorkspaceInput extends PluginEnv {
     /** Repo-relative config file path, a global input; defaults to `CONFIG_FILE`. */
     configFile?: string;
@@ -16,6 +25,14 @@ export interface Workspace {
     readonly globalInputs: readonly string[];
     readonly ignore: readonly string[];
     readonly warnings: readonly Warning[];
+    /** Registered schemes, core first; clashes are checked on release. */
+    readonly schemes: readonly SchemeEntry[];
+    /** Core sources first, then enabled plugins in config order. */
+    readonly intents: readonly IntentEntry[];
+    /** Bumps and branch rules with defaults applied. */
+    readonly release: ReleaseSettings;
+    /** Fixed groups, sorted by name. */
+    readonly groups: readonly Group[];
 }
 /** Runs plugin hooks sequentially in config order and builds the graph. */
 export declare const loadWorkspace: (input: WorkspaceInput) => Promise<Workspace>;

package/dist/workspace.js

@@ -1,7 +1,11 @@
+import { corePlugin } from "./builtin.js";
 import { CONFIG_FILE } from "./config.js";
 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 { collectSchemes } from "./schemes.js";
 import { uniqueSorted } from "./util.js";
 const collectEdges = async (active, config, units) => {
     const edges = [];
@@ -46,6 +50,15 @@ export const loadWorkspace = async (input) => {
     const units = await discoverUnits(active, input);
     const graph = buildGraph(units, await collectEdges(active, input.config, units));
     const globalInputs = await collectGlobalInputs(active, input.config, input.configFile ?? CONFIG_FILE);
+    const groups = resolveGroups(units, input.config.groups, warnings);
+    const intents = [
+        { plugin: corePlugin, options: {} },
+        ...active.map(({ plugin, ctx }) => ({ plugin, options: ctx.options })),
+    ].flatMap(({ plugin, options }) => (plugin.intent ?? []).map((source) => ({
+        plugin: plugin.name,
+        options,
+        source,
+    })));
     return {
         repo: input.repo.name,
         units,
@@ -53,5 +66,9 @@ export const loadWorkspace = async (input) => {
         globalInputs,
         ignore: input.config.ignore ?? [],
         warnings: [...warnings, ...graph.warnings],
+        schemes: collectSchemes(active),
+        intents,
+        release: releaseSettings(input.config),
+        groups,
     };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tallyrelease/core",
-  "version": "0.1.1-beta.1",
+  "version": "0.2.0-beta.8",
   "description": "Pure planning core of tallyrelease",
   "repository": {
     "type": "git",
@@ -47,7 +47,8 @@
   "prettier": "@abinnovision/prettier-config",
   "dependencies": {
     "@standard-schema/spec": "^1.1.0",
-    "picomatch": "^4.0.7"
+    "picomatch": "^4.0.7",
+    "semver": "^7.8.5"
   },
   "devDependencies": {
     "@abinnovision/eslint-config-base": "^3.4.2",
@@ -55,6 +56,7 @@
     "@internal/tsconfig": "0.0.0",
     "@types/node": "^24.19.2",
     "@types/picomatch": "^4.0.3",
+    "@types/semver": "^7.8.0",
     "@vitest/coverage-v8": "^5.0.4",
     "esbuild": "^0.28.2",
     "eslint": "^10.12.0",