rolldown-pnpm-config 0.8.1 → 1.0.0

package/plugin/freeze.js

@@ -20,16 +20,23 @@ const WRAPPED_KEYS = /* @__PURE__ */ new Set([
 	"enforcement",
 	"excludeByRepo"
 ]);
-/** True only when `input` is the wrapped form: a `value` key and no foreign keys.
-*  This disambiguates from a record-valued field that happens to contain a
-*  `value` key (e.g. `overrides: { value: ">=1", lodash: ">=4" }`), which has
-*  keys outside the recognized set and is therefore treated as a bare value. */
+/**
+* True only when `input` is the wrapped `{ value, enforcement?, excludeByRepo? }`
+* form: a `value` key and no foreign keys. This disambiguates from a
+* record-valued field that happens to contain a `value` key (e.g.
+* `overrides: { value: ">=1", lodash: ">=4" }`), which has keys outside the
+* recognized set and is therefore treated as a bare value. The single
+* definition of "wrapped" — the CLI's static readers use it too.
+*
+* @internal
+*/
 function isWrappedField(input) {
+	if (input === null || typeof input !== "object") return false;
 	const keys = Object.keys(input);
 	return keys.includes("value") && keys.every((k) => WRAPPED_KEYS.has(k));
 }
 function normalizeField(input) {
-	if (input !== null && typeof input === "object" && isWrappedField(input)) {
+	if (isWrappedField(input)) {
 		const o = input;
 		return {
 			value: o.value,
@@ -81,4 +88,4 @@ function freeze(config) {
 }
 
 //#endregion
-export { ConfigError, freeze };
+export { ConfigError, freeze, isWrappedField };

package/runtime/strategies/arrays.js

@@ -1,4 +1,5 @@
 //#region src/runtime/strategies/arrays.ts
+/** Union `managed` with `local` (when present), deduped and sorted for a stable render. @internal */
 function unionSort(managed, local) {
 	const set = new Set(managed);
 	for (const item of local ?? []) set.add(item);
@@ -34,4 +35,4 @@ const arrayRecordUnion = (base, local) => {
 };
 
 //#endregion
-export { arrayRecordUnion, arrayUnion };
+export { arrayRecordUnion, arrayUnion, unionSort };

package/runtime/strategies/catalogs.js

@@ -1,3 +1,5 @@
+import { mergeMapDetect } from "./overrides.js";
+
 //#region src/runtime/strategies/catalogs.ts
 /**
 * Merge each named catalog; child wins per package. Emits override divergences
@@ -11,20 +13,9 @@ const catalogs = (base, local) => {
 	const divergences = [];
 	const merged = { ...child };
 	for (const [name, entries] of Object.entries(managed)) {
-		const childCat = child[name] ?? {};
-		const out = { ...entries };
-		for (const [pkg, childVersion] of Object.entries(childCat)) {
-			const managedVersion = entries[pkg];
-			if (managedVersion !== void 0 && managedVersion !== childVersion) divergences.push({
-				setting: `catalogs.${name}.${pkg}`,
-				managedValue: managedVersion,
-				localValue: childVersion,
-				detail: "Local version overrides the managed version.",
-				kind: "override"
-			});
-			out[pkg] = childVersion;
-		}
-		merged[name] = out;
+		const cat = mergeMapDetect(`catalogs.${name}`, entries, child[name] ?? {});
+		merged[name] = cat.merged;
+		divergences.push(...cat.divergences);
 	}
 	return {
 		merged,

package/runtime/strategies/overrides.js

@@ -1,4 +1,12 @@
+import { unionSort } from "./arrays.js";
+
 //#region src/runtime/strategies/overrides.ts
+/**
+* Child wins per key over a managed string map; any differing key is reported
+* as an override divergence under `<prefix>.<key>`.
+*
+* @internal
+*/
 function mergeMapDetect(prefix, managed, child) {
 	const merged = { ...managed };
 	const divergences = [];
@@ -42,16 +50,15 @@ const peerDependencyRules = (base, local) => {
 	const managed = base ?? {};
 	const child = local ?? {};
 	const av = mergeMapDetect("peerDependencyRules.allowedVersions", managed.allowedVersions ?? {}, child.allowedVersions ?? {});
-	const union = (s = [], c = []) => [.../* @__PURE__ */ new Set([...s, ...c])].sort((a, b) => a.localeCompare(b));
 	return {
 		merged: {
 			allowedVersions: av.merged,
-			ignoreMissing: union(managed.ignoreMissing, child.ignoreMissing),
-			allowAny: union(managed.allowAny, child.allowAny)
+			ignoreMissing: unionSort(managed.ignoreMissing ?? [], child.ignoreMissing),
+			allowAny: unionSort(managed.allowAny ?? [], child.allowAny)
 		},
 		divergences: av.divergences
 	};
 };
 
 //#endregion
-export { overrides, peerDependencyRules };
+export { mergeMapDetect, overrides, peerDependencyRules };

package/runtime/strategies/scalar.js

@@ -31,9 +31,9 @@ const securityFlag = (base, local) => {
 	};
 };
 /**
-* `child ?? base`; flags when child lowers the value. Field-agnostic, so it
-* emits `setting: ""`; the runtime fills the field name. Detects
-* minimum-release-age loosening.
+* `child ?? base`; flags when child lowers a managed numeric floor (e.g. the
+* release-age quarantine). Field-agnostic, so it emits `setting: ""`; the
+* runtime fills the field name.
 *
 * @internal
 */
@@ -44,7 +44,7 @@ const securityMin = (base, local) => {
 		setting: "",
 		managedValue: String(base),
 		localValue: String(local),
-		detail: `Shortens the release-age quarantine from ${base} to ${local} minutes.`,
+		detail: `Lowers a managed security minimum from ${base} to ${local}.`,
 		kind: "security"
 	});
 	return {

package/runtime/strategies/table.js

@@ -1,7 +1,7 @@
 import { arrayRecordUnion, arrayUnion } from "./arrays.js";
+import { overrides, peerDependencyRules } from "./overrides.js";
 import { catalogs } from "./catalogs.js";
 import { allowBuilds, mapChildWins } from "./maps.js";
-import { overrides, peerDependencyRules } from "./overrides.js";
 import { scalar, securityFlag, securityMin } from "./scalar.js";
 
 //#region src/runtime/strategies/table.ts

package/semver-util.js

@@ -0,0 +1,29 @@
+import { Result } from "effect";
+import { Range, SemVer } from "@effected/semver";
+
+//#region src/semver-util.ts
+/**
+* Parse a version string synchronously, returning null instead of failing
+* (filters junk dist-tags and unparseable literals). Build-time only.
+*
+* @internal
+*/
+const parseVersion = (v) => Result.getOrNull(SemVer.parseResult(v));
+/**
+* Parse a range expression synchronously, returning null instead of failing.
+* Build-time only.
+*
+* @internal
+*/
+const parseRange = (r) => Result.getOrNull(Range.parseResult(r));
+/**
+* Strip a leading range operator to the bare version digits (e.g. `^3.17.0`
+* → `3.17.0`, `>=1.2.3 <2` → `1.2.3`). The single definition shared by the
+* plugin engine's peer-prefix transform and the CLI's floor derivations.
+*
+* @internal
+*/
+const bareVersion = (range) => range.replace(/^[\^~>=<\s]+/, "").split(/\s/)[0] ?? range;
+
+//#endregion
+export { bareVersion, parseRange, parseVersion };