@effected/changesets 0.5.1 → 0.6.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/index.js CHANGED
@@ -3,10 +3,15 @@ import { BumpType, ReleaseType } from "./BumpType.js";
3
3
  import { Changelog, ChangelogError, ComprehensiveRelease, ModCompWithPackage, NewChangeset, NewChangesetWithCommit, PackageJSON, VersionType } from "./Changelog.js";
4
4
  import { ChangesetConfig } from "./ChangesetConfig.js";
5
5
  import { ChangesetFile, ParsedChangeset } from "./ChangesetFile.js";
6
- import { ChangesetConfigError, ChangesetParseError, MissingPackageError, SnapshotPreModeError, SnapshotTemplateError, UnknownPackageError } from "./errors.js";
6
+ import { AmbiguousPackageError, ChangesetConfigError, ChangesetParseError, LedgerError, MissingPackageError, SnapshotPreModeError, SnapshotTemplateError, UnknownPackageError, VersioningError } from "./errors.js";
7
+ import { Ledger, LedgerEntry } from "./Ledger.js";
7
8
  import { PendingChangeset, PendingChangesets } from "./PendingChangesets.js";
8
9
  import { PreState } from "./PreState.js";
10
+ import { RegistryVersions } from "./RegistryVersions.js";
11
+ import { ReleaseCause } from "./ReleaseCause.js";
9
12
  import { ChangesetMove, ManifestEdit, RangeEdit, ReleaseEdits } from "./ReleaseEdits.js";
13
+ import { ReleaseManager } from "./ReleaseManager.js";
10
14
  import { PlannedRelease, ReleaseContext, ReleasePlan } from "./ReleasePlan.js";
15
+ import { EpicOutOfBand, FixedOutOfStep, VersioningCheck } from "./VersioningCheck.js";
11
16
 
12
- export { BreakingFloor, BumpType, Changelog, ChangelogError, ChangesetConfig, ChangesetConfigError, ChangesetFile, ChangesetMove, ChangesetParseError, ComprehensiveRelease, FloorCause, ManifestEdit, MissingPackageError, ModCompWithPackage, NewChangeset, NewChangesetWithCommit, PackageJSON, ParsedChangeset, PendingChangeset, PendingChangesets, PlannedRelease, PreState, RangeEdit, ReleaseContext, ReleaseEdits, ReleasePlan, ReleaseType, SnapshotPreModeError, SnapshotTemplateError, UnknownPackageError, VersionType };
17
+ export { AmbiguousPackageError, BreakingFloor, BumpType, Changelog, ChangelogError, ChangesetConfig, ChangesetConfigError, ChangesetFile, ChangesetMove, ChangesetParseError, ComprehensiveRelease, EpicOutOfBand, FixedOutOfStep, FloorCause, Ledger, LedgerEntry, LedgerError, ManifestEdit, MissingPackageError, ModCompWithPackage, NewChangeset, NewChangesetWithCommit, PackageJSON, ParsedChangeset, PendingChangeset, PendingChangesets, PlannedRelease, PreState, RangeEdit, RegistryVersions, ReleaseCause, ReleaseContext, ReleaseEdits, ReleaseManager, ReleasePlan, ReleaseType, SnapshotPreModeError, SnapshotTemplateError, UnknownPackageError, VersionType, VersioningCheck, VersioningError };
@@ -0,0 +1,610 @@
1
+ import { AmbiguousPackageError, UnknownPackageError, VersioningError } from "../errors.js";
2
+ import { normalizeProjectDir } from "../Ledger.js";
3
+ import { sortCauses } from "../ReleaseCause.js";
4
+ import { parseRange } from "./versions.js";
5
+ import { Range, SemVer } from "@effected/semver";
6
+ import { Result } from "effect";
7
+ import { PnpmMatcher } from "@effected/pnpm";
8
+
9
+ // src/internal/pnpmPlan.ts
10
+ /** Ends planning with a typed failure; never escapes {@link planPnpm}. */
11
+ var Halt = class {
12
+ failure;
13
+ constructor(failure) {
14
+ this.failure = failure;
15
+ }
16
+ };
17
+ const BUMP_ORDER = {
18
+ none: 0,
19
+ patch: 1,
20
+ minor: 2,
21
+ major: 3
22
+ };
23
+ const maxBump = (a, b) => a === void 0 || BUMP_ORDER[b] > BUMP_ORDER[a] ? b : a;
24
+ /** pnpm's spelling of a project directory; the root package (`"."`) is `""`. */
25
+ const projectDir = (relativePath) => normalizeProjectDir(relativePath === "." ? "" : relativePath);
26
+ const byKey = (a, b) => a < b ? -1 : a > b ? 1 : 0;
27
+ const parse = (version) => Result.getOrUndefined(SemVer.parseResult(version));
28
+ const mustParse = (version) => {
29
+ const parsed = parse(version);
30
+ if (parsed === void 0) throw new Error(`pnpm planner: ${version} was admitted as a participant version`);
31
+ return parsed;
32
+ };
33
+ const stablePart = (version) => `${version.major}.${version.minor}.${version.patch}`;
34
+ const isPrerelease = (version) => version.prerelease.length > 0;
35
+ const incStable = (version, bump) => bump === "major" ? `${version.major + 1}.0.0` : bump === "minor" ? `${version.major}.${version.minor + 1}.0` : `${version.major}.${version.minor}.${version.patch + 1}`;
36
+ /** `escalate_stable_target`, plan/versions.rs:112. */
37
+ const escalate = (target, bump) => {
38
+ const version = mustParse(target);
39
+ if (bump === "major") return version.minor === 0 && version.patch === 0 ? target : `${version.major + 1}.0.0`;
40
+ if (bump === "minor") return version.patch === 0 ? target : `${version.major}.${version.minor + 1}.0`;
41
+ return target;
42
+ };
43
+ /** `stable_target`, plan/versions.rs:80. */
44
+ const stableTarget = (version, bump) => isPrerelease(version) ? escalate(stablePart(version), bump) : incStable(version, bump);
45
+ /** A numeric identifier compares as its digits, as pnpm matches the tag (plan/versions.rs:88-96). */
46
+ const preTag = (version) => {
47
+ const first = version.prerelease[0];
48
+ return first === void 0 ? void 0 : String(first);
49
+ };
50
+ /** `next_prerelease_number`, plan/versions.rs:137. */
51
+ const nextPrereleaseNumber = (current, target, lane) => {
52
+ if (!isPrerelease(current) || stablePart(current) !== target || preTag(current) !== lane) return 0;
53
+ const n = current.prerelease[1];
54
+ return typeof n === "number" ? n + 1 : 0;
55
+ };
56
+ /** `compute_new_version`, plan/versions.rs:28. */
57
+ const computeNewVersion = (current, bump, lane, cumulative, firstRelease) => {
58
+ const version = mustParse(current);
59
+ if (lane === void 0) {
60
+ if (firstRelease) return current;
61
+ return isPrerelease(version) ? escalate(stablePart(version), cumulative) : incStable(version, bump);
62
+ }
63
+ if (firstRelease) return preTag(version) === lane ? current : `${stablePart(version)}-${lane}.0`;
64
+ const target = stableTarget(version, cumulative);
65
+ return `${target}-${lane}.${nextPrereleaseNumber(version, target, lane)}`;
66
+ };
67
+ /** `materialize_workspace_range`, plan/versions.rs:348. */
68
+ const materialize = (spec, dependencyVersion) => {
69
+ if (!spec.startsWith("workspace:")) return void 0;
70
+ const rest = spec.slice(10);
71
+ const alias = workspaceAlias(rest);
72
+ const range = alias === void 0 ? rest : rest.slice(alias.length + 1);
73
+ return range === "^" || range === "~" ? `${range}${dependencyVersion}` : range === "*" || range === "" ? dependencyVersion : range;
74
+ };
75
+ /** `range_accepts`, plan/versions.rs:362: a range or version that does not parse accepts nothing. */
76
+ const rangeAccepts = (range, version) => {
77
+ const parsedRange = parseRange(range);
78
+ const parsedVersion = parse(version);
79
+ return parsedRange !== void 0 && parsedVersion !== void 0 && Range.satisfies(parsedVersion, parsedRange);
80
+ };
81
+ /** `parse_workspace_spec_alias`, plan/project_refs.rs:222. */
82
+ const workspaceAlias = (rest) => {
83
+ const at = rest.lastIndexOf("@");
84
+ if (at <= 0) return void 0;
85
+ const alias = rest.slice(0, at);
86
+ if (/^[._/]/.test(alias) || alias.slice(1).includes("@")) return void 0;
87
+ return alias;
88
+ };
89
+ const PROD_FIELDS = [
90
+ "dependencies",
91
+ "optionalDependencies",
92
+ "peerDependencies"
93
+ ];
94
+ /** The workspace's projects and references, `index_project_refs` (plan/project_refs.rs:73). */
95
+ var Refs = class {
96
+ dirs;
97
+ byName = /* @__PURE__ */ new Map();
98
+ constructor(projects) {
99
+ this.dirs = new Set(projects.map((project) => project.dir));
100
+ for (const project of projects) this.byName.set(project.name, [...this.byName.get(project.name) ?? [], project.dir]);
101
+ }
102
+ nameToDirs(name) {
103
+ return this.byName.get(name) ?? [];
104
+ }
105
+ refToDirs(reference) {
106
+ if (!reference.startsWith("./")) return this.nameToDirs(reference);
107
+ const dir = normalizeProjectDir(reference);
108
+ return this.dirs.has(dir) ? [dir] : [];
109
+ }
110
+ /** `resolve_config_ref` (plan/project_refs.rs:242): unknown is skipped, ambiguous fails. */
111
+ config(reference, setting) {
112
+ const dirs = this.refToDirs(reference);
113
+ if (dirs.length > 1) throw new Halt(new VersioningError({
114
+ reason: "ambiguousPackage",
115
+ package: reference,
116
+ context: setting,
117
+ directories: [...dirs]
118
+ }));
119
+ return dirs;
120
+ }
121
+ };
122
+ /** `internal_dep_target_name`, plan/project_refs.rs:208. */
123
+ const internalTarget = (alias, spec, refs) => {
124
+ if (spec.startsWith("workspace:")) {
125
+ const target = workspaceAlias(spec.slice(10)) ?? alias;
126
+ return refs.nameToDirs(target).length > 0 ? target : void 0;
127
+ }
128
+ if (refs.nameToDirs(alias).length === 0) return void 0;
129
+ return spec.startsWith("catalog:") || parseRange(spec) !== void 0 ? alias : void 0;
130
+ };
131
+ /** The release-structure half of `resolve_workspace` (plan.rs:175), validated against itself. */
132
+ const resolveWorkspace = (projects, versioning) => {
133
+ const refs = new Refs(projects);
134
+ const ignored = new Set((versioning?.ignore ?? []).flatMap((reference) => refs.config(reference, "versioning.ignore")));
135
+ const participants = /* @__PURE__ */ new Map();
136
+ for (const project of [...projects].sort((a, b) => byKey(a.dir, b.dir))) {
137
+ if (project.version === void 0 || parse(project.version) === void 0 || ignored.has(project.dir)) continue;
138
+ participants.set(project.dir, {
139
+ dir: project.dir,
140
+ name: project.name,
141
+ current: project.version,
142
+ private: project.private,
143
+ internalDeps: []
144
+ });
145
+ }
146
+ for (const project of projects) {
147
+ const participant = participants.get(project.dir);
148
+ if (participant === void 0) continue;
149
+ const deps = [];
150
+ for (const dep of project.prod) {
151
+ const targetName = internalTarget(dep.alias, dep.spec, refs);
152
+ if (targetName === void 0) continue;
153
+ const targets = refs.nameToDirs(targetName).filter((dir) => participants.has(dir));
154
+ if (targets.length === 0) continue;
155
+ if (targets.length > 1) throw new Halt(new VersioningError({
156
+ reason: "ambiguousPackage",
157
+ package: targetName,
158
+ context: `Package ${participant.name} (./${participant.dir})`,
159
+ directories: targets
160
+ }));
161
+ deps.push({
162
+ targetDir: targets[0],
163
+ targetName,
164
+ field: dep.field,
165
+ alias: dep.alias,
166
+ spec: dep.spec
167
+ });
168
+ }
169
+ participant.internalDeps = deps;
170
+ }
171
+ const lanes = /* @__PURE__ */ new Map();
172
+ for (const [reference, lane] of Object.entries(versioning?.lanes ?? {})) for (const dir of refs.config(reference, "versioning.lanes")) lanes.set(dir, lane);
173
+ const declaredFixed = versioning?.fixed ?? [];
174
+ const fixed = declaredFixed.map((group) => group.flatMap((reference) => refs.config(reference, "versioning.fixed")).filter((dir) => participants.has(dir)));
175
+ fixed.forEach((group, index) => {
176
+ if (new Set(group.map((dir) => lanes.get(dir))).size > 1) throw new Halt(new VersioningError({
177
+ reason: "conflictingConfig",
178
+ group: [...declaredFixed[index] ?? []]
179
+ }));
180
+ });
181
+ const epics = [];
182
+ for (const epic of versioning?.epics ?? []) {
183
+ const leadDir = refs.config(epic.lead, "versioning.epics lead")[0];
184
+ if (leadDir === void 0 || !participants.has(leadDir)) throw new Halt(new VersioningError({
185
+ reason: "epicUnknownLead",
186
+ lead: epic.lead
187
+ }));
188
+ const selectors = epic.packages.map((selector) => {
189
+ const negated = selector.startsWith("!");
190
+ const body = negated ? selector.slice(1) : selector;
191
+ const onDir = body.startsWith("./");
192
+ return {
193
+ negated,
194
+ onDir,
195
+ matches: PnpmMatcher.compile([onDir ? normalizeProjectDir(body) : body])
196
+ };
197
+ });
198
+ const members = [];
199
+ for (const participant of participants.values()) {
200
+ if (participant.dir === leadDir) continue;
201
+ let included = false;
202
+ for (const selector of selectors) if (selector.matches(selector.onDir ? participant.dir : participant.name)) included = !selector.negated;
203
+ if (included) members.push(participant.dir);
204
+ }
205
+ epics.push({
206
+ lead: epic.lead,
207
+ leadDir,
208
+ members
209
+ });
210
+ }
211
+ const epicOf = /* @__PURE__ */ new Map();
212
+ for (const epic of epics) {
213
+ for (const member of epic.members) {
214
+ const other = epicOf.get(member);
215
+ if (other !== void 0 && other !== epic.lead) throw new Halt(new VersioningError({
216
+ reason: "epicOverlap",
217
+ directories: [member],
218
+ lead: other,
219
+ secondLead: epic.lead
220
+ }));
221
+ epicOf.set(member, epic.lead);
222
+ }
223
+ for (const group of fixed) {
224
+ if (!group.some((dir) => epic.members.includes(dir))) continue;
225
+ const outsiders = group.filter((dir) => !epic.members.includes(dir));
226
+ if (outsiders.length > 0) throw new Halt(new VersioningError({
227
+ reason: "epicFixedGroupConflict",
228
+ lead: epic.lead,
229
+ directories: outsiders
230
+ }));
231
+ }
232
+ }
233
+ return {
234
+ refs,
235
+ participants,
236
+ lanes,
237
+ fixed,
238
+ epics
239
+ };
240
+ };
241
+ /** `resolve_intents`, plan/configuration.rs:215. */
242
+ const resolveIntents = (changesets, workspace) => changesets.map((changeset) => {
243
+ const bumps = /* @__PURE__ */ new Map();
244
+ for (const [reference, bump] of changeset.releases) {
245
+ const dirs = workspace.refs.refToDirs(reference);
246
+ if (dirs.length === 0) throw new Halt(new UnknownPackageError({
247
+ packageName: reference,
248
+ changeset: changeset.file,
249
+ code: "ERR_PNPM_VERSIONING_UNKNOWN_PACKAGE"
250
+ }));
251
+ if (dirs.length > 1) throw new Halt(new AmbiguousPackageError({
252
+ packageName: reference,
253
+ directories: [...dirs],
254
+ changeset: changeset.file,
255
+ code: "ERR_PNPM_VERSIONING_AMBIGUOUS_PACKAGE"
256
+ }));
257
+ const dir = dirs[0];
258
+ if (bump !== "none" && !workspace.participants.has(dir)) throw new Halt(new VersioningError({
259
+ reason: "unreleasablePackage",
260
+ package: reference,
261
+ bump,
262
+ changeset: changeset.file
263
+ }));
264
+ const existing = bumps.get(dir);
265
+ if (existing === void 0 || BUMP_ORDER[bump] > BUMP_ORDER[existing]) bumps.set(dir, bump);
266
+ }
267
+ return {
268
+ changeset,
269
+ bumps
270
+ };
271
+ });
272
+ /** `build_consumption_index`, ledger.rs:280. */
273
+ const consumptionIndex = (ledger, refs) => {
274
+ const stable = /* @__PURE__ */ new Map();
275
+ const prerelease = /* @__PURE__ */ new Map();
276
+ for (const entry of ledger?.entries ?? []) {
277
+ let dir;
278
+ if (entry.dir !== void 0) dir = normalizeProjectDir(entry.dir);
279
+ else {
280
+ const dirs = refs.nameToDirs(entry.name);
281
+ if (dirs.length === 0) continue;
282
+ if (dirs.length > 1) throw new Halt(new VersioningError({
283
+ reason: "ambiguousLedgerEntry",
284
+ ledgerKey: `${entry.name}@${entry.version}`,
285
+ package: entry.name,
286
+ directories: [...dirs]
287
+ }));
288
+ dir = dirs[0];
289
+ }
290
+ const target = (entry.version.split("+")[0] ?? "").includes("-") ? prerelease : stable;
291
+ const ids = target.get(dir) ?? /* @__PURE__ */ new Set();
292
+ for (const id of entry.intents) ids.add(id);
293
+ target.set(dir, ids);
294
+ }
295
+ const index = /* @__PURE__ */ new Map();
296
+ for (const dir of /* @__PURE__ */ new Set([...stable.keys(), ...prerelease.keys()])) {
297
+ const s = stable.get(dir) ?? /* @__PURE__ */ new Set();
298
+ const p = prerelease.get(dir) ?? /* @__PURE__ */ new Set();
299
+ index.set(dir, {
300
+ all: /* @__PURE__ */ new Set([...s, ...p]),
301
+ prereleaseOnly: new Set([...p].filter((id) => !s.has(id)))
302
+ });
303
+ }
304
+ return index;
305
+ };
306
+ const realBump = (bump) => bump === void 0 || bump === "none" ? void 0 : bump;
307
+ /** `bump_at_least`, plan/propagation.rs:290: true when it inserted or raised. */
308
+ const bumpAtLeast = (state, dir, bump, cause) => {
309
+ const existing = state.get(dir);
310
+ if (existing === void 0) {
311
+ state.set(dir, {
312
+ bump,
313
+ causes: /* @__PURE__ */ new Set([cause])
314
+ });
315
+ return true;
316
+ }
317
+ existing.causes.add(cause);
318
+ if (BUMP_ORDER[bump] > BUMP_ORDER[existing.bump]) {
319
+ existing.bump = bump;
320
+ return true;
321
+ }
322
+ return false;
323
+ };
324
+ /** `assemble`, plan.rs:339, for one set of unpublished directories. */
325
+ const assembleOnce = (ctx, unpublished) => {
326
+ const { workspace, intents, consumption } = ctx;
327
+ const dirs = [...workspace.participants.keys()];
328
+ const pending = /* @__PURE__ */ new Map();
329
+ const laneConsumed = /* @__PURE__ */ new Map();
330
+ for (const dir of dirs) {
331
+ const consumed = consumption.get(dir);
332
+ const own = intents.filter((intent) => realBump(intent.bumps.get(dir)) !== void 0);
333
+ const stillPending = own.filter((intent) => !(consumed?.all.has(intent.changeset.id) ?? false));
334
+ if (stillPending.length > 0) pending.set(dir, stillPending);
335
+ const onLane = own.filter((intent) => consumed?.prereleaseOnly.has(intent.changeset.id) ?? false);
336
+ if (onLane.length > 0) laneConsumed.set(dir, onLane);
337
+ }
338
+ const highest = (dir, list) => list.reduce((high, intent) => {
339
+ const bump = realBump(intent.bumps.get(dir));
340
+ return bump === void 0 ? high : maxBump(high, bump);
341
+ }, void 0);
342
+ const state = /* @__PURE__ */ new Map();
343
+ for (const [dir, list] of pending) {
344
+ const bump = highest(dir, list);
345
+ if (bump !== void 0) bumpAtLeast(state, dir, bump, "intent");
346
+ }
347
+ for (const [dir, list] of laneConsumed) {
348
+ if (workspace.lanes.has(dir)) continue;
349
+ const bump = highest(dir, list);
350
+ if (bump !== void 0) bumpAtLeast(state, dir, bump, "intent");
351
+ }
352
+ const cumulative = (dir, planned) => maxBump(highest(dir, laneConsumed.get(dir) ?? []), planned);
353
+ const participant = (dir) => workspace.participants.get(dir);
354
+ const rebaseFloor = (epic, next) => {
355
+ const lead = next.get(epic.leadDir);
356
+ const leadVersion = lead === void 0 ? void 0 : parse(lead);
357
+ if (leadVersion === void 0 || isPrerelease(leadVersion)) return void 0;
358
+ const currentMajor = leadBandMajor(mustParse(participant(epic.leadDir).current));
359
+ return leadVersion.major > currentMajor ? leadVersion.major * 100 : void 0;
360
+ };
361
+ const computeVersions = () => {
362
+ const next = /* @__PURE__ */ new Map();
363
+ for (const dir of [...state.keys()].sort(byKey)) {
364
+ const entry = state.get(dir);
365
+ next.set(dir, computeNewVersion(participant(dir).current, entry.bump, workspace.lanes.get(dir), cumulative(dir, entry.bump), unpublished.has(dir)));
366
+ }
367
+ for (const group of workspace.fixed) {
368
+ let groupBump;
369
+ for (const dir of group) {
370
+ const entry = state.get(dir);
371
+ if (entry !== void 0) groupBump = maxBump(groupBump, cumulative(dir, entry.bump));
372
+ }
373
+ if (groupBump === void 0 || group.length === 0) continue;
374
+ const highestCurrent = group.map((dir) => mustParse(participant(dir).current)).reduce((high, version) => version.gt(high) ? version : high);
375
+ const target = stableTarget(highestCurrent, groupBump);
376
+ const lane = workspace.lanes.get(group[0]);
377
+ const shared = lane === void 0 ? target : `${target}-${lane}.${Math.max(...group.map((dir) => nextPrereleaseNumber(mustParse(participant(dir).current), target, lane)))}`;
378
+ for (const dir of group) if (state.has(dir)) next.set(dir, shared);
379
+ }
380
+ for (const epic of workspace.epics) {
381
+ const floor = rebaseFloor(epic, next);
382
+ if (floor === void 0) continue;
383
+ const target = `${floor}.0.0`;
384
+ for (const member of epic.members) {
385
+ if (!state.has(member)) continue;
386
+ const lane = workspace.lanes.get(member);
387
+ next.set(member, lane === void 0 ? target : `${target}-${lane}.${nextPrereleaseNumber(mustParse(participant(member).current), target, lane)}`);
388
+ }
389
+ }
390
+ return next;
391
+ };
392
+ const propagate = (next) => {
393
+ let changed = false;
394
+ for (const dependent of workspace.participants.values()) for (const dep of dependent.internalDeps) {
395
+ const targetNew = next.get(dep.targetDir);
396
+ if (targetNew === void 0) continue;
397
+ const range = materialize(dep.spec, participant(dep.targetDir).current);
398
+ if (range === void 0 || rangeAccepts(range, targetNew)) continue;
399
+ changed = bumpAtLeast(state, dependent.dir, "patch", "dependencies") || changed;
400
+ }
401
+ for (const group of workspace.fixed) {
402
+ let groupBump;
403
+ for (const dir of group) {
404
+ const entry = state.get(dir);
405
+ if (entry !== void 0) groupBump = maxBump(groupBump, entry.bump);
406
+ }
407
+ if (groupBump === void 0) continue;
408
+ for (const dir of group) changed = bumpAtLeast(state, dir, groupBump, "fixed") || changed;
409
+ }
410
+ for (const epic of workspace.epics) {
411
+ if (rebaseFloor(epic, next) === void 0) continue;
412
+ for (const member of epic.members) changed = bumpAtLeast(state, member, "major", "epic") || changed;
413
+ }
414
+ return changed;
415
+ };
416
+ let next = computeVersions();
417
+ while (propagate(next)) next = computeVersions();
418
+ const releases = [...state.keys()].sort(byKey).map((dir) => {
419
+ const entry = state.get(dir);
420
+ const own = [...pending.get(dir) ?? [], ...workspace.lanes.has(dir) ? [] : laneConsumed.get(dir) ?? []];
421
+ return {
422
+ name: participant(dir).name,
423
+ dir,
424
+ type: entry.bump,
425
+ oldVersion: participant(dir).current,
426
+ newVersion: ctx.snapshotSuffix === void 0 ? next.get(dir) : `0.0.0-${ctx.snapshotSuffix}`,
427
+ changesets: own.map((intent) => intent.changeset.id),
428
+ causes: sortCauses(entry.causes)
429
+ };
430
+ });
431
+ releases.sort((a, b) => byKey(a.name, b.name) || byKey(a.dir, b.dir));
432
+ const identities = /* @__PURE__ */ new Map();
433
+ for (const release of releases) {
434
+ const identity = `${release.name}@${release.newVersion}`;
435
+ const first = identities.get(identity);
436
+ if (first !== void 0) throw new Halt(new VersioningError({
437
+ reason: "duplicateRelease",
438
+ package: release.name,
439
+ version: release.newVersion,
440
+ directories: [first, release.dir]
441
+ }));
442
+ identities.set(identity, release.dir);
443
+ }
444
+ if (ctx.snapshotSuffix === void 0) {
445
+ enforceEpicBands(workspace, next, rebaseFloor);
446
+ enforceMaxBump(releases, ctx);
447
+ }
448
+ return releases;
449
+ };
450
+ /** `epic_lead_band_major`, plan/versions.rs:237: a lead on `N.0.0-<lane>.x` is still in the band of `N-1`. */
451
+ const leadBandMajor = (lead) => isPrerelease(lead) && lead.minor === 0 && lead.patch === 0 ? Math.max(0, lead.major - 1) : lead.major;
452
+ /**
453
+ * The major an epic's band derives from, `epic_band` (plan/versions.rs:295): the
454
+ * re-base floor's when the lead crosses to a new stable major, else the lead's
455
+ * current. Planning and {@link checkPnpm} both read it here.
456
+ */
457
+ const epicBandMajor = (workspace, epic, floor) => floor !== void 0 ? floor / 100 : leadBandMajor(mustParse(workspace.participants.get(epic.leadDir).current));
458
+ /** `enforce_epic_bands`, plan/versions.rs:316. */
459
+ const enforceEpicBands = (workspace, next, rebaseFloor) => {
460
+ for (const epic of workspace.epics) {
461
+ const floor = rebaseFloor(epic, next);
462
+ const bandMajor = epicBandMajor(workspace, epic, floor);
463
+ for (const member of epic.members) {
464
+ const version = next.get(member);
465
+ if (version === void 0) continue;
466
+ const major = mustParse(version).major;
467
+ if (major < bandMajor * 100 || major > bandMajor * 100 + 99) throw new Halt(new VersioningError({
468
+ reason: "epicOutOfBand",
469
+ package: workspace.participants.get(member).name,
470
+ version,
471
+ lead: epic.lead,
472
+ bandMajor
473
+ }));
474
+ }
475
+ }
476
+ };
477
+ /** `enforce_max_bump` and `effective_bump_class`, plan/versions.rs:369-436. */
478
+ const enforceMaxBump = (releases, ctx) => {
479
+ const cap = ctx.versioning?.maxBump;
480
+ if (cap === void 0) return;
481
+ for (const release of releases) {
482
+ const current = parse(release.oldVersion);
483
+ const next = parse(release.newVersion);
484
+ let effective = release.type;
485
+ if (current !== void 0 && next !== void 0) {
486
+ const distance = next.major !== current.major ? "major" : next.minor !== current.minor ? "minor" : next.patch !== current.patch ? "patch" : void 0;
487
+ if (distance !== void 0) effective = maxBump(effective, distance);
488
+ }
489
+ if (BUMP_ORDER[effective] <= BUMP_ORDER[cap]) continue;
490
+ const files = ctx.intents.filter((intent) => release.changesets.includes(intent.changeset.id) && [...intent.changeset.releases.values()].includes(effective)).map((intent) => `.changeset/${intent.changeset.file}`);
491
+ throw new Halt(new VersioningError({
492
+ reason: "maxBumpExceeded",
493
+ package: release.name,
494
+ bump: effective,
495
+ maxBump: cap,
496
+ raisedBy: files.length > 0 ? files : [...release.causes]
497
+ }));
498
+ }
499
+ };
500
+ /** A workspace package as the planner reads a project. */
501
+ const toProject = (pkg) => ({
502
+ dir: projectDir(pkg.relativePath),
503
+ name: pkg.name,
504
+ version: pkg.version,
505
+ private: pkg.private,
506
+ prod: PROD_FIELDS.flatMap((field) => Object.entries(pkg[field]).map(([alias, spec]) => ({
507
+ field,
508
+ alias,
509
+ spec
510
+ })))
511
+ });
512
+ /**
513
+ * Plan a pnpm-native release. With `published` the plan is made twice, as
514
+ * `pnpm version -r` makes it (crates/cli/src/cli_args/version/release.rs:86-115):
515
+ * once with nothing unpublished, then again with every public release of that
516
+ * first plan whose directory `published` lacks treated as a first release
517
+ * (`unpublished_release_dirs`, crates/cli/src/cli_args/changelog.rs:251). pnpm's
518
+ * probe asks whether the registry has exactly the manifest version
519
+ * (`package.versions.contains_key(version)`, changelog.rs:322), which is what
520
+ * a directory's membership means.
521
+ */
522
+ const planPnpm = (input) => {
523
+ try {
524
+ const projects = input.packages.map(toProject);
525
+ const workspace = resolveWorkspace(projects, input.versioning);
526
+ const changesets = input.changesets.filter((changeset) => !changeset.file.startsWith("pre/"));
527
+ const intents = resolveIntents(changesets, workspace);
528
+ if (input.enforceWorkspaceProtocol === true) for (const participant of workspace.participants.values()) {
529
+ const dep = participant.internalDeps.find((d) => !d.spec.startsWith("workspace:"));
530
+ if (dep !== void 0) throw new Halt(new VersioningError({
531
+ reason: "internalRange",
532
+ package: participant.name,
533
+ dependency: {
534
+ alias: dep.alias,
535
+ field: dep.field,
536
+ specifier: dep.spec
537
+ }
538
+ }));
539
+ }
540
+ const ctx = {
541
+ workspace,
542
+ intents,
543
+ consumption: consumptionIndex(input.ledger, workspace.refs),
544
+ versioning: input.versioning,
545
+ snapshotSuffix: input.snapshotSuffix
546
+ };
547
+ const unpublishedGiven = input.unpublished;
548
+ let releases = assembleOnce(ctx, unpublishedGiven ?? /* @__PURE__ */ new Set());
549
+ const published = unpublishedGiven === void 0 ? input.published : void 0;
550
+ if (published !== void 0) {
551
+ const unpublished = new Set(releases.filter((release) => !workspace.participants.get(release.dir).private).filter((release) => !published.has(release.dir)).map((release) => release.dir));
552
+ if (unpublished.size > 0) releases = assembleOnce(ctx, unpublished);
553
+ }
554
+ const consumedIds = new Set(releases.flatMap((release) => release.changesets));
555
+ return Result.succeed({
556
+ releases,
557
+ consumed: changesets.filter((changeset) => consumedIds.has(changeset.id))
558
+ });
559
+ } catch (error) {
560
+ if (error instanceof Halt) return Result.fail(error.failure);
561
+ throw error;
562
+ }
563
+ };
564
+ /**
565
+ * `check_versioning_invariants` (plan.rs:217): the committed versions against the
566
+ * epic bands and fixed groups `versioning` declares. A configuration pnpm
567
+ * refuses fails first, as `resolve_workspace` fails it; otherwise every
568
+ * violation is returned, epic members first in directory order, then fixed
569
+ * groups in declaration order. With no plan the band comes from the lead's
570
+ * current major (`push_epic_band_violations`, plan.rs:249).
571
+ */
572
+ const checkPnpm = (input) => {
573
+ try {
574
+ const projects = input.packages.map(toProject);
575
+ const workspace = resolveWorkspace(projects, input.versioning);
576
+ const violations = [];
577
+ for (const epic of workspace.epics) {
578
+ const bandMajor = epicBandMajor(workspace, epic, void 0);
579
+ for (const dir of [...epic.members].sort(byKey)) {
580
+ const member = workspace.participants.get(dir);
581
+ const major = mustParse(member.current).major;
582
+ if (major < bandMajor * 100 || major > bandMajor * 100 + 99) violations.push({
583
+ _tag: "EpicOutOfBand",
584
+ epic: epic.lead,
585
+ package: member.name,
586
+ version: member.current,
587
+ major,
588
+ bandMajor
589
+ });
590
+ }
591
+ }
592
+ (input.versioning?.fixed ?? []).forEach((declared, index) => {
593
+ const members = (workspace.fixed[index] ?? []).map((dir) => workspace.participants.get(dir));
594
+ if (new Set(members.map((member) => member.current)).size > 1) violations.push({
595
+ _tag: "FixedOutOfStep",
596
+ group: [...declared],
597
+ versions: members.map((member) => ({
598
+ package: member.name,
599
+ version: member.current
600
+ }))
601
+ });
602
+ });
603
+ return Result.succeed(violations);
604
+ } catch (error) {
605
+ if (error instanceof Halt && error.failure instanceof VersioningError) return Result.fail(error.failure);
606
+ throw error;
607
+ }
608
+ };
609
+
610
+ export { checkPnpm, planPnpm, projectDir };
@@ -0,0 +1,21 @@
1
+ import { AmbiguousPackageError } from "../errors.js";
2
+
3
+ // src/internal/twins.ts
4
+ /**
5
+ * The refusal every name-keyed reader of a plan shares: a pnpm plan, keyed by
6
+ * directory, may hold two releases with one name (same-named projects, each
7
+ * named by its `./` key), and a reader keyed by name would silently let one
8
+ * overwrite the other. The first such name, with every directory releasing it.
9
+ *
10
+ * @internal
11
+ */
12
+ const twinReleases = (releases) => {
13
+ const dirs = /* @__PURE__ */ new Map();
14
+ for (const release of releases) dirs.set(release.name, [...dirs.get(release.name) ?? [], release.dir ?? ""]);
15
+ for (const [name, list] of dirs) if (list.length > 1) return new AmbiguousPackageError({
16
+ packageName: name,
17
+ directories: list
18
+ });
19
+ };
20
+
21
+ export { twinReleases };
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@effected/changesets",
3
- "version": "0.5.1",
3
+ "version": "0.6.0",
4
4
  "private": false,
5
5
  "description": "Changeset files, `.changeset/config.json` and the release plan as Effect schemas and pure functions.",
6
6
  "keywords": [
@@ -43,13 +43,15 @@
43
43
  },
44
44
  "dependencies": {
45
45
  "@effected/glob": "^0.22.0",
46
+ "@effected/pnpm": "^0.1.0",
46
47
  "@effected/semver": "^0.24.0",
47
- "@effected/workspaces": "^0.47.1",
48
+ "@effected/workspaces": "^0.48.0",
48
49
  "@effected/yaml": "^0.30.0"
49
50
  },
50
51
  "peerDependencies": {
51
52
  "@effected/markdown": "^0.29.0",
52
53
  "@effected/markdown-lint": "^0.2.0",
54
+ "@effected/npm": "^0.35.0",
53
55
  "effect": "~4.1.0"
54
56
  },
55
57
  "peerDependenciesMeta": {