rolldown-pnpm-config 2.0.4 → 2.1.1

package/catalogs.js

@@ -1,5 +1,11 @@
 //#region src/catalogs.ts
 /**
+* The install range of a catalog spec (bare string or `{ range }` object).
+*
+* @internal
+*/
+const rangeOf = (spec) => typeof spec === "string" ? spec : spec.range;
+/**
 * Normalize declarative catalog input into the resolved `{ catalog → pkg → range }`
 * map consumed by the runtime. Pure: the base catalog uses each package's
 * `range` (or bare string); a peers catalog is emitted only for packages
@@ -25,4 +31,4 @@ function normalizeCatalogs(input) {
 }
 
 //#endregion
-export { normalizeCatalogs };
+export { normalizeCatalogs, rangeOf };

package/cli/version.js

@@ -6,7 +6,7 @@
 *
 * @internal
 */
-const CLI_VERSION = "2.0.4";
+const CLI_VERSION = "2.1.1";
 
 //#endregion
 export { CLI_VERSION };

package/index.d.ts

@@ -70,6 +70,40 @@ interface AllowedVersionsFromCatalogs {
   readonly prefix?: string | null;
 }
 //#endregion
+//#region src/plugin/overrides-from-catalogs.d.ts
+/**
+ * A directive that derives pnpm `overrides` from a catalog, so every member of
+ * a release family resolves to the catalog's exact version everywhere in a
+ * consumer's graph: direct requests, transitive requests from other packages,
+ * and peer edges alike. A catalog range alone cannot do that, since a caret
+ * admits a newer member and a catalog never reaches a dependency's own
+ * dependencies. For each member whose range is a simple operator on a plain
+ * `X.Y.Z` version, an entry `"<name>@<selector>": "<X.Y.Z>"` is emitted.
+ *
+ * @remarks
+ * Under the default `scope: "line"` the selector is the member's release line,
+ * `^X.0.0` (`^0.Y.0` on a 0.x line, `~0.0.0` on 0.0.x), so a request for a *different* major
+ * (or a prerelease, which no caret line admits) is left alone. Prerelease and
+ * compound-range members are skipped rather than widened. An override entry
+ * authored by hand wins over a derived one on the same selector, and the
+ * consumer's own `overrides` still win over the plugin's at install time.
+ *
+ * @public
+ */
+interface OverridesFromCatalogs {
+  /** The catalog whose members are pinned. */
+  readonly catalog: string;
+  /** Members left out, e.g. a tool that rides the catalog but is not part of the release family. */
+  readonly exclude?: readonly string[];
+  /**
+   * How each selector is scoped. `"line"` (the default) qualifies the package
+   * name with its caret line, so only requests on that line are pinned;
+   * `"any"` emits the bare package name, which pins every request regardless
+   * of the line it asked for.
+   */
+  readonly scope?: "line" | "any";
+}
+//#endregion
 //#region src/runtime/types.d.ts
 /**
  * How a field's divergences are enforced: silent, console warning, or a thrown
@@ -131,7 +165,7 @@ interface PluginConfig {
      * folder detection is independent and unaffected.
      */
     readonly localPatchesDir?: string;
-  } & { readonly [K in keyof PluginConfig]?: PluginConfig[K] | LocalDirective<PluginConfig[K]>; };
+  } & { readonly [K in Exclude<keyof PluginConfig, "overridesFromCatalogs">]?: PluginConfig[K] | LocalDirective<PluginConfig[K]>; };
   /** Whether pnpm prompts before purging `node_modules`. */
   readonly confirmModulesPurge?: FieldInput<boolean>;
   /** Per-package manifest overrides merged into the dependency graph. */
@@ -166,6 +200,14 @@ interface PluginConfig {
   readonly auditConfig?: FieldInput<Record<string, string[]>>;
   /** Security version overrides, keyed by package selector. */
   readonly overrides?: FieldInput<Record<string, string>>;
+  /**
+   * Derive `overrides` from a catalog (or several), pinning every member of a
+   * release family to its exact catalog version across the whole consumer
+   * graph. Resolved and merged under `overrides` at build time, so the
+   * pnpmfile, `export` and `preview` all carry the result; an authored
+   * `overrides` entry wins on a selector clash. Not a pnpm field itself.
+   */
+  readonly overridesFromCatalogs?: OverridesFromCatalogs | readonly OverridesFromCatalogs[];
   /** Peer dependency rules: allowed versions plus ignore/allow-any lists. */
   readonly peerDependencyRules?: FieldInput<{
     readonly allowedVersions?: Record<string, string>;
@@ -420,5 +462,5 @@ interface PluginConfig {
  */
 export declare function PnpmConfigPlugin(config: PluginConfig): Plugin;
 //#endregion
-export type { AllowedVersionsFromCatalogs, CatalogDeclaration, CatalogPackageSpec, Enforcement, FieldInput, LocalDirective, PeerStrategy, PluginConfig, VersionSource };
+export type { AllowedVersionsFromCatalogs, CatalogDeclaration, CatalogPackageSpec, Enforcement, FieldInput, LocalDirective, OverridesFromCatalogs, PeerStrategy, PluginConfig, VersionSource };
 //# sourceMappingURL=index.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "rolldown-pnpm-config",
-	"version": "2.0.4",
+	"version": "2.1.1",
 	"private": false,
 	"description": "A dogfooding example of our plugin",
 	"repository": {
@@ -35,16 +35,16 @@
 		"rolldown-pnpm-config": "bin/rolldown-pnpm-config.js"
 	},
 	"dependencies": {
-		"@effect/platform-node": "4.0.2",
-		"@effected/cli": "^0.16.2",
-		"@effected/env": "^0.1.2",
-		"@effected/glob": "^0.10.1",
-		"@effected/npm": "^0.20.1",
-		"@effected/semver": "^0.11.1",
-		"@effected/walker": "^0.15.1",
-		"@effected/workspaces": "^0.32.1",
-		"@effected/yaml": "^0.19.2",
-		"effect": "4.0.2",
+		"@effect/platform-node": "^4.0.3",
+		"@effected/cli": "^0.17.0",
+		"@effected/env": "^0.2.0",
+		"@effected/glob": "^0.11.0",
+		"@effected/npm": "^0.21.0",
+		"@effected/semver": "^0.12.0",
+		"@effected/walker": "^0.16.0",
+		"@effected/workspaces": "^0.33.0",
+		"@effected/yaml": "^0.20.0",
+		"effect": "^4.0.3",
 		"ink": "^8.0.0",
 		"oxc-parser": "^0.153.0",
 		"react": "^19.3.0"

package/plugin/allowed-versions.js

@@ -1,10 +1,9 @@
+import { rangeOf } from "../catalogs.js";
 import { bareVersion } from "../semver-util.js";
 
 //#region src/plugin/allowed-versions.ts
 /** An exact version: no range operator, no wildcard — `X.Y.Z` with an optional prerelease. */
 const EXACT_VERSION = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
-/** The install range of a catalog spec (bare string or `{ range }` object). */
-const rangeOf = (spec) => typeof spec === "string" ? spec : spec.range;
 /** Apply the `prefix` transform to a peer value: verbatim, re-prefixed, or stripped to exact. */
 function applyPrefix(peerValue, prefix) {
 	if (prefix === void 0) return peerValue;

package/plugin/freeze.js

@@ -2,6 +2,7 @@ import { normalizeCatalogs } from "../catalogs.js";
 import { DESCRIPTORS, deriveSchemas } from "../descriptors/index.js";
 import { FIELD_REGISTRY } from "../registry.js";
 import { resolvePeerDependencyRules } from "./allowed-versions.js";
+import { resolveOverrides } from "./overrides-from-catalogs.js";
 import { Data, Effect, Schema } from "effect";
 
 //#region src/plugin/freeze.ts
@@ -62,15 +63,20 @@ function freeze(config) {
 			enforcement: "warn"
 		};
 		if (typeof config.name !== "string" || config.name.trim() === "") return yield* Effect.fail(new ConfigError({ message: "Config `name` is required and must be a non-empty string" }));
+		const directiveError = (error) => new ConfigError({ message: error instanceof Error ? error.message : String(error) });
 		for (const [field, reg] of Object.entries(FIELD_REGISTRY)) {
 			if (field === "catalogs") continue;
-			const raw = config[field];
+			let raw = config[field];
+			if (raw === void 0 && field === "overrides" && config.overridesFromCatalogs !== void 0) raw = {};
 			if (raw === void 0) continue;
 			const decl = normalizeField(raw);
 			const schema = FIELD_SCHEMAS[field];
 			const value = field === "peerDependencyRules" ? yield* Effect.try({
 				try: () => resolvePeerDependencyRules(decl.value, config.catalogs),
-				catch: (error) => new ConfigError({ message: error instanceof Error ? error.message : String(error) })
+				catch: directiveError
+			}) : field === "overrides" ? yield* Effect.try({
+				try: () => resolveOverrides(decl.value, config.overridesFromCatalogs, config.catalogs),
+				catch: directiveError
 			}) : decl.value;
 			base[field] = schema ? yield* Schema.decodeUnknownEffect(schema)(value).pipe(Effect.mapError((error) => new ConfigError({ message: `Invalid ${field}: ${String(error)}` }))) : value;
 			manifest[field] = {

package/plugin/overrides-from-catalogs.js

@@ -0,0 +1,69 @@
+import { rangeOf } from "../catalogs.js";
+import { bareVersion } from "../semver-util.js";
+
+//#region src/plugin/overrides-from-catalogs.ts
+/** A plain release version: `X.Y.Z`, no prerelease, no build metadata. */
+const PLAIN_VERSION = /^(\d+)\.(\d+)\.(\d+)$/;
+/** A simple-operator range: an optional `^`, `~`, `>=` or `=` on one version. */
+const SIMPLE_RANGE = /^(?:\^|~|>=|=)?\s*\d/;
+/**
+* The release line a plain version belongs to: `^X.0.0`, or `^0.Y.0` when the
+* major is 0. A `0.0.Z` version has no caret line (`^0.0.0` admits only
+* `0.0.0` itself), so it takes the tilde line `~0.0.0`, which covers every
+* `0.0.Z` request.
+*/
+function releaseLine(major, minor) {
+	if (major !== "0") return `^${major}.0.0`;
+	return minor === "0" ? "~0.0.0" : `^0.${minor}.0`;
+}
+/** Derive the overrides for one directive. Pure; throws when the catalog or an excluded member is absent. */
+function deriveOne(catalogs, { catalog, exclude = [], scope = "line" }) {
+	const decl = catalogs[catalog];
+	if (decl === void 0) throw new Error(`overridesFromCatalogs: catalog "${catalog}" is not declared`);
+	for (const name of exclude) if (!(name in decl.packages)) throw new Error(`overridesFromCatalogs: excluded member "${name}" is not in catalog "${catalog}"`);
+	const excluded = new Set(exclude);
+	const table = {};
+	for (const [name, spec] of Object.entries(decl.packages)) {
+		if (excluded.has(name)) continue;
+		const range = rangeOf(spec);
+		if (!SIMPLE_RANGE.test(range) || /\s/.test(range.trim())) continue;
+		const version = bareVersion(range);
+		const match = PLAIN_VERSION.exec(version);
+		if (match === null) continue;
+		const selector = scope === "any" ? name : `${name}@${releaseLine(match[1], match[2])}`;
+		table[selector] = version;
+	}
+	return table;
+}
+/**
+* Merge the derived overrides for one or more directives (later directives win
+* on a selector clash).
+*
+* @internal
+*/
+function deriveOverrides(catalogs, directives) {
+	const list = Array.isArray(directives) ? directives : [directives];
+	const out = {};
+	for (const d of list) Object.assign(out, deriveOne(catalogs, d));
+	return out;
+}
+/**
+* Resolve the `overrides` value a plugin ships: the derived table from the
+* directive, with the authored entries merged over it so a hand-written
+* selector wins. Without a directive the authored value passes through
+* untouched (by reference, so an absent field stays absent).
+*
+* @internal
+*/
+function resolveOverrides(authored, directives, catalogs) {
+	if (directives === void 0) return authored;
+	const derived = deriveOverrides(catalogs, directives);
+	const manual = authored !== null && typeof authored === "object" ? authored : {};
+	return {
+		...derived,
+		...manual
+	};
+}
+
+//#endregion
+export { deriveOverrides, resolveOverrides };