rolldown-pnpm-config 0.1.0

package/cli/ui/env.js

@@ -0,0 +1,20 @@
+import { hasTTY, isAgent, isCI, isColorSupported } from "std-env";
+import { supportsHyperlinks } from "std-osc8";
+
+//#region src/cli/ui/env.ts
+/**
+* Detect color / interactivity / hyperlink support once, at the command edge.
+* The render layer consumes the returned flags and never reads the environment.
+*
+* @internal
+*/
+function detectCapabilities() {
+	return {
+		color: isColorSupported,
+		interactive: hasTTY && !isCI && !isAgent,
+		hyperlinks: supportsHyperlinks
+	};
+}
+
+//#endregion
+export { detectCapabilities, supportsHyperlinks };

package/cli/ui/run-preview.js

@@ -0,0 +1,23 @@
+import { Preview } from "./Preview.js";
+import { Effect } from "effect";
+import { render } from "ink";
+import { createElement } from "react";
+
+//#region src/cli/ui/run-preview.ts
+/**
+* Render the interactive Preview inside an Effect, resolving once the user
+* exits and Ink has fully torn down.
+*
+* @internal
+*/
+function runPreview(views) {
+	return Effect.async((resume) => {
+		render(createElement(Preview, {
+			views,
+			onExit: () => {}
+		})).waitUntilExit().then(() => resume(Effect.void));
+	});
+}
+
+//#endregion
+export { runPreview };

package/cli/ui/run-walk.js

@@ -0,0 +1,29 @@
+import { Walk } from "./Walk.js";
+import { Effect } from "effect";
+import { render } from "ink";
+import { createElement } from "react";
+
+//#region src/cli/ui/run-walk.ts
+/**
+* Render the interactive Walk inside an Effect, resolving with the collected
+* decisions once the user finishes (or immediately when nothing is actionable),
+* after Ink has fully exited.
+*
+* @internal
+*/
+function runWalk(items) {
+	return Effect.async((resume) => {
+		let collected = [];
+		render(createElement(Walk, {
+			items,
+			onDone: (d) => {
+				collected = d;
+			}
+		})).waitUntilExit().then(() => {
+			resume(Effect.succeed([...collected]));
+		});
+	});
+}
+
+//#endregion
+export { runWalk };

package/cli/ui/styled.js

@@ -0,0 +1,27 @@
+//#region src/cli/ui/styled.ts
+/** SGR open/close codes per style (close is always 0=reset for simplicity). @internal */
+const ANSI_OPEN = {
+	added: "\x1B[32m",
+	removed: "\x1B[31m",
+	changed: "\x1B[33m",
+	warn: "\x1B[31m",
+	local: "\x1B[35m",
+	unmanaged: "\x1B[2m",
+	unchanged: "\x1B[2m",
+	plain: ""
+};
+const ANSI_RESET = "\x1B[0m";
+/** Apply (or omit) the SGR code for a style. @internal */
+function paint(text, style, color) {
+	if (!color || style === "plain" || ANSI_OPEN[style] === "") return text;
+	return `${ANSI_OPEN[style]}${text}${ANSI_RESET}`;
+}
+/** The trailing annotation for a tag, e.g. "  (local)". @internal */
+function tagSuffix(tag) {
+	if (tag === "local") return "  (local)";
+	if (tag === "unmanaged") return "  (unmanaged)";
+	return "";
+}
+
+//#endregion
+export { ANSI_OPEN, paint, tagSuffix };

package/cli/walk-plan.js

@@ -0,0 +1,35 @@
+import { derivePeerRange } from "./peer-range.js";
+import { detectPeerDrift } from "./drift.js";
+import { planEntry } from "./plan.js";
+import { Effect } from "effect";
+
+//#region src/cli/walk-plan.ts
+/**
+* Build the interactive walk items: for each entry, its candidate list (from
+* planEntry against the resolved versions), an up-to-date flag (only the keep
+* candidate remains), and any peer drift resync target.
+*
+* @internal
+*/
+function buildWalkItems(entries, versionsByPkg) {
+	return Effect.gen(function* () {
+		const items = [];
+		for (const entry of entries) {
+			const candidates = yield* planEntry(entry, [...versionsByPkg.get(entry.pkg) ?? []]);
+			const driftPeer = yield* detectPeerDrift(entry);
+			const materializePeer = entry.strategy && !entry.peer ? yield* derivePeerRange(entry.currentRange, entry.strategy) : null;
+			const upToDate = candidates.length === 1 && driftPeer === null && materializePeer === null;
+			items.push({
+				entry,
+				candidates,
+				upToDate,
+				driftPeer,
+				materializePeer
+			});
+		}
+		return items;
+	});
+}
+
+//#endregion
+export { buildWalkItems };

package/cli/walk-reducer.js

@@ -0,0 +1,61 @@
+//#region src/cli/walk-reducer.ts
+/** Index of the next actionable (not up-to-date) item at or after `from`, or -1. */
+function nextActionable(items, from) {
+	for (let i = from; i < items.length; i++) if (!items[i].upToDate) return i;
+	return -1;
+}
+/**
+* Initialize the walk on the first actionable item (auto-skipping up-to-date
+* items). If none are actionable, the walk is immediately done.
+*
+* @internal
+*/
+function initWalk(items) {
+	const index = nextActionable(items, 0);
+	return {
+		index: index === -1 ? items.length : index,
+		cursor: 0,
+		decisions: [],
+		done: index === -1
+	};
+}
+/**
+* Advance the walk by a key. up/down move the cursor within the current item's
+* candidates; enter records the highlighted candidate and moves to the next
+* actionable item (or completes).
+*
+* @internal
+*/
+function walkStep(state, items, key) {
+	if (state.done) return state;
+	const item = items[state.index];
+	const count = item.candidates.length;
+	if (key === "up") return {
+		...state,
+		cursor: (state.cursor - 1 + count) % count
+	};
+	if (key === "down") return {
+		...state,
+		cursor: (state.cursor + 1) % count
+	};
+	const chosen = item.candidates[state.cursor];
+	const decisions = [...state.decisions, {
+		item,
+		chosen
+	}];
+	const next = nextActionable(items, state.index + 1);
+	if (next === -1) return {
+		...state,
+		decisions,
+		done: true
+	};
+	return {
+		index: next,
+		cursor: 0,
+		decisions,
+		done: false
+	};
+}
+
+//#endregion
+export { initWalk, walkStep };

package/cli/workspace-file.js

@@ -0,0 +1,58 @@
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { parse, stringify } from "yaml";
+
+//#region src/cli/workspace-file.ts
+const FILENAME = "pnpm-workspace.yaml";
+const STRINGIFY_OPTIONS = {
+	indent: 2,
+	lineWidth: 0,
+	singleQuote: false
+};
+/** True when every element is a string/number/boolean (safe to sort). */
+function allPrimitive(arr) {
+	return arr.every((v) => v === null || typeof v !== "object" && typeof v !== "function");
+}
+/**
+* Canonical form for deterministic output and diffing: object keys alpha-sorted
+* recursively; arrays of all-primitive elements sorted lexicographically;
+* arrays containing objects keep their order.
+*
+* @internal
+*/
+function canonicalize(value) {
+	if (Array.isArray(value)) {
+		const mapped = value.map(canonicalize);
+		return allPrimitive(mapped) ? [...mapped].sort((a, b) => String(a).localeCompare(String(b))) : mapped;
+	}
+	if (value !== null && typeof value === "object") return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => [k, canonicalize(v)]));
+	return value;
+}
+/**
+* Walk up from `startDir` to the nearest directory containing a
+* pnpm-workspace.yaml; returns the file path or null.
+*
+* @internal
+*/
+function findWorkspaceFile(startDir) {
+	let dir = startDir;
+	for (;;) {
+		const candidate = join(dir, FILENAME);
+		if (existsSync(candidate)) return candidate;
+		const parent = dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
+/** Parse pnpm-workspace.yaml source; empty/whitespace yields an empty object. @internal */
+function parseWorkspace(source) {
+	const parsed = parse(source);
+	return parsed && typeof parsed === "object" ? parsed : {};
+}
+/** Render a workspace object: deterministic key sort + yaml.stringify. @internal */
+function renderWorkspace(obj) {
+	return stringify(canonicalize(obj), STRINGIFY_OPTIONS);
+}
+
+//#endregion
+export { canonicalize, findWorkspaceFile, parseWorkspace, renderWorkspace };

package/cli/workspace-overlay.js

@@ -0,0 +1,21 @@
+//#region src/cli/workspace-overlay.ts
+/**
+* Overlay the plugin's managed fields onto a parsed pnpm-workspace.yaml object.
+* Managed top-level fields overwrite; `catalogs` is overlaid by catalog name
+* (plugin names replace, local names are preserved); every other key in the
+* parsed file is kept verbatim. Nothing is deleted. Pure.
+*
+* @internal
+*/
+function overlayWorkspace(managed, parsed) {
+	const out = { ...parsed };
+	for (const [key, value] of Object.entries(managed)) if (key === "catalogs" && value && typeof value === "object") out.catalogs = {
+		...parsed.catalogs && typeof parsed.catalogs === "object" ? parsed.catalogs : {},
+		...value
+	};
+	else out[key] = value;
+	return out;
+}
+
+//#endregion
+export { overlayWorkspace };

package/descriptors/build.js

@@ -0,0 +1,248 @@
+import { Bool, Num, Str, StringArray, StringRecord, UnknownRecord } from "./schemas.js";
+import { Schema } from "effect";
+
+//#region src/descriptors/build.ts
+/** The 26 build / scripts + patches + injection fields. @internal */
+const build = {
+	onlyBuiltDependencies: {
+		schema: StringArray,
+		kind: "stringArray",
+		strategy: "arrayUnion",
+		enforcement: "warn",
+		doc: "Packages whose build scripts are allowed to run; others are blocked.",
+		workspaceYaml: true,
+		anchor: "onlybuiltdependencies"
+	},
+	onlyBuiltDependenciesFile: {
+		schema: Str,
+		kind: "string",
+		strategy: "scalar",
+		enforcement: "warn",
+		doc: "Path to a JSON file listing packages whose build scripts are allowed.",
+		workspaceYaml: true,
+		anchor: "onlybuiltdependenciesfile"
+	},
+	neverBuiltDependencies: {
+		schema: StringArray,
+		kind: "stringArray",
+		strategy: "arrayUnion",
+		enforcement: "absent",
+		doc: "Packages whose build scripts are never executed.",
+		workspaceYaml: true,
+		anchor: "neverbuiltdependencies"
+	},
+	ignoredBuiltDependencies: {
+		schema: StringArray,
+		kind: "stringArray",
+		strategy: "arrayUnion",
+		enforcement: "absent",
+		doc: "Packages excluded from the list of dependencies to build.",
+		workspaceYaml: true,
+		anchor: "ignoredbuiltdependencies"
+	},
+	dangerouslyAllowAllBuilds: {
+		schema: Bool,
+		kind: "boolean",
+		strategy: "scalar",
+		enforcement: "warn",
+		doc: "When true, all build scripts are allowed to run without restriction.",
+		workspaceYaml: true,
+		anchor: "dangerouslyallowallbuilds"
+	},
+	ignoreScripts: {
+		schema: Bool,
+		kind: "boolean",
+		strategy: "scalar",
+		enforcement: "absent",
+		doc: "Whether lifecycle scripts of packages in node_modules are not executed.",
+		workspaceYaml: true,
+		anchor: "ignorescripts"
+	},
+	ignoreDepScripts: {
+		schema: Bool,
+		kind: "boolean",
+		strategy: "scalar",
+		enforcement: "absent",
+		doc: "Whether lifecycle scripts of dependencies are ignored during install.",
+		workspaceYaml: true,
+		anchor: "ignoredepscripts"
+	},
+	childConcurrency: {
+		schema: Num,
+		kind: "number",
+		strategy: "scalar",
+		enforcement: "absent",
+		doc: "Maximum number of child processes that build scripts can spawn concurrently.",
+		workspaceYaml: true,
+		anchor: "childconcurrency"
+	},
+	sideEffectsCache: {
+		schema: Bool,
+		kind: "boolean",
+		strategy: "scalar",
+		enforcement: "absent",
+		doc: "Whether the results of running install scripts are cached.",
+		workspaceYaml: true,
+		anchor: "sideeffectscache"
+	},
+	sideEffectsCacheReadonly: {
+		schema: Bool,
+		kind: "boolean",
+		strategy: "scalar",
+		enforcement: "absent",
+		doc: "Whether the side effects cache is used but never updated.",
+		workspaceYaml: true,
+		anchor: "sideeffectscachereadonly"
+	},
+	nodeOptions: {
+		schema: Str,
+		kind: "string",
+		strategy: "scalar",
+		enforcement: "absent",
+		doc: "Options passed to Node.js via NODE_OPTIONS when running scripts.",
+		workspaceYaml: true,
+		anchor: "nodeoptions"
+	},
+	verifyDepsBeforeRun: {
+		schema: Schema.Union(Schema.Literal("install", "warn", "error", "prompt"), Schema.Boolean),
+		kind: "union",
+		strategy: "scalar",
+		enforcement: "absent",
+		doc: "Whether pnpm verifies that the install is up to date before running scripts.",
+		workspaceYaml: true,
+		anchor: "verifydepsbeforerun",
+		samples: {
+			valid: ["install", false],
+			invalid: ["x"]
+		}
+	},
+	enablePrePostScripts: {
+		schema: Bool,
+		kind: "boolean",
+		strategy: "scalar",
+		enforcement: "absent",
+		doc: "Whether pre/post lifecycle scripts are run automatically alongside the main script.",
+		workspaceYaml: true,
+		anchor: "enableprepostscripts"
+	},
+	scriptShell: {
+		schema: Str,
+		kind: "string",
+		strategy: "scalar",
+		enforcement: "absent",
+		doc: "The shell used to execute scripts.",
+		workspaceYaml: true,
+		anchor: "scriptshell"
+	},
+	shellEmulator: {
+		schema: Bool,
+		kind: "boolean",
+		strategy: "scalar",
+		enforcement: "absent",
+		doc: "Whether a POSIX shell emulator is used when running scripts on Windows.",
+		workspaceYaml: true,
+		anchor: "shellemulator"
+	},
+	requiredScripts: {
+		schema: StringArray,
+		kind: "stringArray",
+		strategy: "arrayUnion",
+		enforcement: "absent",
+		doc: "Scripts that must exist in every project matching the current filter.",
+		workspaceYaml: true,
+		anchor: "requiredscripts"
+	},
+	patchedDependencies: {
+		schema: StringRecord,
+		kind: "stringRecord",
+		strategy: "mapChildWins",
+		enforcement: "warn",
+		doc: "Patches applied to dependencies, keyed by package identifier.",
+		workspaceYaml: true,
+		anchor: "patcheddependencies"
+	},
+	allowUnusedPatches: {
+		schema: Bool,
+		kind: "boolean",
+		strategy: "scalar",
+		enforcement: "absent",
+		doc: "Whether unused patches (patches that apply to no installed package) are allowed.",
+		workspaceYaml: true,
+		anchor: "allowunusedpatches"
+	},
+	allowNonAppliedPatches: {
+		schema: Bool,
+		kind: "boolean",
+		strategy: "scalar",
+		enforcement: "absent",
+		doc: "Whether non-applied patches (patches that fail to apply) are allowed.",
+		workspaceYaml: true,
+		anchor: "allownonappliedpatches"
+	},
+	ignorePatchFailures: {
+		schema: Bool,
+		kind: "boolean",
+		strategy: "scalar",
+		enforcement: "absent",
+		doc: "Whether patch failures are silently ignored during installation.",
+		workspaceYaml: true,
+		anchor: "ignorepatchfailures"
+	},
+	patchesDir: {
+		schema: Str,
+		kind: "string",
+		strategy: "scalar",
+		enforcement: "absent",
+		doc: "Directory where patch files are stored (default: patches).",
+		workspaceYaml: true,
+		anchor: "patchesdir"
+	},
+	configDependencies: {
+		schema: StringRecord,
+		kind: "stringRecord",
+		strategy: "mapChildWins",
+		enforcement: "absent",
+		doc: "Packages installed before other packages so their config scripts can run first.",
+		workspaceYaml: true,
+		anchor: "configdependencies"
+	},
+	executionEnv: {
+		schema: UnknownRecord,
+		kind: "unknownRecord",
+		strategy: "mapChildWins",
+		enforcement: "absent",
+		doc: "Environment variables applied when running scripts.",
+		workspaceYaml: true,
+		anchor: "executionenv"
+	},
+	injectWorkspacePackages: {
+		schema: Bool,
+		kind: "boolean",
+		strategy: "scalar",
+		enforcement: "absent",
+		doc: "Whether local workspace packages are injected instead of symlinked.",
+		workspaceYaml: true,
+		anchor: "injectworkspacepackages"
+	},
+	syncInjectedDepsAfterScripts: {
+		schema: StringArray,
+		kind: "stringArray",
+		strategy: "arrayUnion",
+		enforcement: "absent",
+		doc: "Scripts after which injected dependencies are re-synced.",
+		workspaceYaml: true,
+		anchor: "syncinjecteddepsafterscripts"
+	},
+	dedupeInjectedDeps: {
+		schema: Bool,
+		kind: "boolean",
+		strategy: "scalar",
+		enforcement: "absent",
+		doc: "Whether injected workspace packages are deduplicated.",
+		workspaceYaml: true,
+		anchor: "dedupeinjecteddeps"
+	}
+};
+
+//#endregion
+export { build };

package/descriptors/hoisting.js

@@ -0,0 +1,175 @@
+import { Bool, Num, Str, StringArray } from "./schemas.js";
+import { Schema } from "effect";
+
+//#region src/descriptors/hoisting.ts
+/** The 17 hoisting + node-modules + store fields. @internal */
+const hoisting = {
+	hoist: {
+		schema: Bool,
+		kind: "boolean",
+		strategy: "scalar",
+		enforcement: "absent",
+		doc: "Whether packages are hoisted to the virtual store root node_modules.",
+		workspaceYaml: true,
+		anchor: "hoist"
+	},
+	hoistWorkspacePackages: {
+		schema: Bool,
+		kind: "boolean",
+		strategy: "scalar",
+		enforcement: "absent",
+		doc: "Whether workspace packages are hoisted to the root node_modules.",
+		workspaceYaml: true,
+		anchor: "hoistworkspacepackages"
+	},
+	hoistPattern: {
+		schema: StringArray,
+		kind: "stringArray",
+		strategy: "arrayUnion",
+		enforcement: "absent",
+		doc: "Glob patterns describing which packages are hoisted to the virtual store root.",
+		workspaceYaml: true,
+		anchor: "hoistpattern"
+	},
+	shamefullyHoist: {
+		schema: Bool,
+		kind: "boolean",
+		strategy: "scalar",
+		enforcement: "absent",
+		doc: "Whether all packages are hoisted to the root node_modules (shameful flat layout).",
+		workspaceYaml: true,
+		anchor: "shamefullyhoist"
+	},
+	hoistingLimits: {
+		schema: Schema.Literal("none", "workspaces", "dependencies"),
+		kind: "enum",
+		strategy: "scalar",
+		enforcement: "absent",
+		doc: "Defines the scope to which dependencies are hoisted.",
+		workspaceYaml: true,
+		anchor: "hoistinglimits",
+		samples: {
+			valid: ["none"],
+			invalid: ["x"]
+		}
+	},
+	modulesDir: {
+		schema: Str,
+		kind: "string",
+		strategy: "scalar",
+		enforcement: "absent",
+		doc: "The directory in which node_modules will be created.",
+		workspaceYaml: true,
+		anchor: "modulesdir"
+	},
+	nodeLinker: {
+		schema: Schema.Literal("isolated", "hoisted", "pnp"),
+		kind: "enum",
+		strategy: "scalar",
+		enforcement: "absent",
+		doc: "Defines which linker is used for installing Node.js packages.",
+		workspaceYaml: true,
+		anchor: "nodelinker",
+		samples: {
+			valid: ["isolated"],
+			invalid: ["x"]
+		}
+	},
+	symlink: {
+		schema: Bool,
+		kind: "boolean",
+		strategy: "scalar",
+		enforcement: "absent",
+		doc: "Whether symlinks are created when linking packages from the store.",
+		workspaceYaml: true,
+		anchor: "symlink"
+	},
+	enableModulesDir: {
+		schema: Bool,
+		kind: "boolean",
+		strategy: "scalar",
+		enforcement: "absent",
+		doc: "Whether the local node_modules directory should be created during install.",
+		workspaceYaml: true,
+		anchor: "enablemodulesdir"
+	},
+	virtualStoreDir: {
+		schema: Str,
+		kind: "string",
+		strategy: "scalar",
+		enforcement: "absent",
+		doc: "The directory with links to the store (default: node_modules/.pnpm).",
+		workspaceYaml: true,
+		anchor: "virtualstoredir"
+	},
+	virtualStoreDirMaxLength: {
+		schema: Num,
+		kind: "number",
+		strategy: "scalar",
+		enforcement: "absent",
+		doc: "Maximum allowed length of directory names inside the virtual store.",
+		workspaceYaml: true,
+		anchor: "virtualstoredirmaxlength"
+	},
+	virtualStoreOnly: {
+		schema: Bool,
+		kind: "boolean",
+		strategy: "scalar",
+		enforcement: "absent",
+		doc: "Whether packages are written only to the virtual store without a local modules dir.",
+		workspaceYaml: true,
+		anchor: "virtualstoreonly"
+	},
+	packageImportMethod: {
+		schema: Schema.Literal("auto", "hardlink", "copy", "clone", "clone-or-copy"),
+		kind: "enum",
+		strategy: "scalar",
+		enforcement: "absent",
+		doc: "Controls how packages are imported from the content-addressable store.",
+		workspaceYaml: true,
+		anchor: "packageimportmethod",
+		samples: {
+			valid: ["auto"],
+			invalid: ["x"]
+		}
+	},
+	modulesCacheMaxAge: {
+		schema: Num,
+		kind: "number",
+		strategy: "scalar",
+		enforcement: "absent",
+		doc: "Maximum age (minutes) of unused modules directories before they are pruned.",
+		workspaceYaml: true,
+		anchor: "modulescachemaxage"
+	},
+	dlxCacheMaxAge: {
+		schema: Num,
+		kind: "number",
+		strategy: "scalar",
+		enforcement: "absent",
+		doc: "Maximum age (minutes) of cached dlx command results before re-fetch.",
+		workspaceYaml: true,
+		anchor: "dlxcachemaxage"
+	},
+	verifyStoreIntegrity: {
+		schema: Bool,
+		kind: "boolean",
+		strategy: "scalar",
+		enforcement: "warn",
+		doc: "Whether integrity checksums in the store are verified before using a package.",
+		workspaceYaml: true,
+		anchor: "verifystoreintegrity"
+	},
+	strictStorePkgContentCheck: {
+		schema: Bool,
+		kind: "boolean",
+		strategy: "scalar",
+		enforcement: "warn",
+		doc: "Whether store package content checksums are verified strictly on each access.",
+		workspaceYaml: true,
+		anchor: "strictstorepkgcontentcheck"
+	}
+};
+
+//#endregion
+export { hoisting };