bun-nested-workspace 0.3.1 → 0.3.2

package/README.md

@@ -113,7 +113,7 @@ A package version patched by both the host and the nested repository is an error
 ### Lockfile
 
 The nested lockfile entries replace the host entries, so the nested packages keep their versions.
-When a replaced entry no longer satisfies a dependency of a host package, the host package keeps its previous resolution as a nested lockfile entry.
+When a replaced entry no longer satisfies a dependency of a host package, the host package keeps its previous resolution, and the nested packages keep theirs.
 When neither satisfies the range, which Bun lockfiles occasionally contain, the dependency gets the highest satisfying version recorded in either lockfile.
 Ranges are checked as `bun install` applies them: an override replaces the declared range, and an `npm:` alias requires the package it names.
 `bun install` then resolves new dependencies of host packages and drops unused entries.
@@ -121,7 +121,7 @@ Ranges are checked as `bun install` applies them: an override replaces the decla
 After the install, the sync compares the direct dependencies of host packages with the original host lockfile.
 A dependency may only change to the version that the nested lockfile hoists to its top level, and only within the host range.
 Any other change means either that the host lockfile did not pin the host dependencies, for example after an edit of a host `package.json` without `bun install`, or that the lockfile cannot record the host version next to the nested one.
-The latter happens to a host workspace without a name, because Bun records workspace-specific versions under the workspace name; name the workspace or align its range with the nested version.
+The latter happens to a host workspace other than the root without a name, because Bun records workspace-specific versions under the workspace name; name the workspace or align its range with the nested version.
 
 Only `bun.lock` with `lockfileVersion` 1 or 2 is supported, because the lockfile format is internal to Bun.
 

package/dist/cli.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
-import { a as syncNestedWorkspace, i as loadNestedWorkspace, n as checkNestedWorkspace, r as isInSync, t as BunInstallError, y as getErrorMessage } from "./workspace-BzA7ccrb.mjs";
+import { a as syncNestedWorkspace, i as loadNestedWorkspace, n as checkNestedWorkspace, r as isInSync, t as BunInstallError, y as getErrorMessage } from "./workspace-ChlHn5I8.mjs";
 // src/cli.ts
 const usage = `Usage:
   bun-nested-workspace [bun install options]  Sync package.json and bun.lock, then run bun install

package/dist/index.d.mts

@@ -194,7 +194,9 @@ export declare function applyManifestToLockfile(lock: Lockfile, manifest: Packag
  * A root entry overridden by the nested lockfile might not satisfy a dependency of a host package:
  * such a dependency gets back its previous host resolution as a nested entry, so `bun install` keeps the host version
  * instead of resolving the range again.
- * A host workspace without a name cannot have nested entries, so `bun install` resolves its dependency again.
+ * A dependency of the host root package gets it back at the top level instead, as `keepHostRootResolutions` describes.
+ * A host workspace other than the root without a name cannot have nested entries,
+ * so `bun install` resolves its dependency again.
  * When the previous host resolution does not satisfy the range either, which Bun lockfiles occasionally contain,
  * the dependency gets the highest satisfying version recorded in either lockfile.
  * Catalog dependencies are checked against the catalogs of the host lockfile, so apply the synced root fields

package/dist/index.mjs

@@ -1 +1 @@
-export { t as BunInstallError, d as applyManifestToLockfile, n as checkNestedWorkspace, g as diffManifests, o as findDirectDependencyMismatches, s as findOwnDependencyChanges, c as findTransitiveMismatches, l as findUncoveredWorkspaces, u as findWorkspaceMismatches, r as isInSync, i as loadNestedWorkspace, f as mergeLockfiles, p as parseLockfile, m as relocateLockfile, h as supportedLockfileVersions, _ as syncManifest, a as syncNestedWorkspace, v as syncedFields } from "./workspace-BzA7ccrb.mjs";
+export { t as BunInstallError, d as applyManifestToLockfile, n as checkNestedWorkspace, g as diffManifests, o as findDirectDependencyMismatches, s as findOwnDependencyChanges, c as findTransitiveMismatches, l as findUncoveredWorkspaces, u as findWorkspaceMismatches, r as isInSync, i as loadNestedWorkspace, f as mergeLockfiles, p as parseLockfile, m as relocateLockfile, h as supportedLockfileVersions, _ as syncManifest, a as syncNestedWorkspace, v as syncedFields } from "./workspace-ChlHn5I8.mjs";

package/dist/{workspace-BzA7ccrb.mjs → workspace-ChlHn5I8.mjs}

@@ -557,7 +557,9 @@ function applyManifestToLockfile(lock, manifest) {
 * A root entry overridden by the nested lockfile might not satisfy a dependency of a host package:
 * such a dependency gets back its previous host resolution as a nested entry, so `bun install` keeps the host version
 * instead of resolving the range again.
-* A host workspace without a name cannot have nested entries, so `bun install` resolves its dependency again.
+* A dependency of the host root package gets it back at the top level instead, as `keepHostRootResolutions` describes.
+* A host workspace other than the root without a name cannot have nested entries,
+* so `bun install` resolves its dependency again.
 * When the previous host resolution does not satisfy the range either, which Bun lockfiles occasionally contain,
 * the dependency gets the highest satisfying version recorded in either lockfile.
 * Catalog dependencies are checked against the catalogs of the host lockfile, so apply the synced root fields
@@ -571,16 +573,16 @@ function mergeLockfiles(lock, nestedLock, dir) {
 		...nestedLock.packages
 	};
 	const hostWorkspaces = Object.entries(lock.workspaces).filter(([workspacePath]) => !isNestedPath(workspacePath, dir));
-	const dependents = [...hostWorkspaces.map(([, workspace]) => ({
+	if (lock.workspaces[""]) keepHostRootResolutions(lock, nestedLock, packages);
+	const dependents = [...hostWorkspaces.flatMap(([workspacePath, workspace]) => workspacePath && workspace.name ? [{
 		key: workspace.name,
 		dependencies: getWorkspaceDependencies(workspace)
-	})), ...Object.keys(packages).map((key) => ({
+	}] : []), ...Object.keys(packages).map((key) => ({
 		key,
 		dependencies: getPackageDependencies(packages[key])
 	}))];
 	for (let index = 0; index < dependents.length; index++) {
 		const { key, dependencies } = dependents[index];
-		if (key === void 0) continue;
 		for (const [dependency, specifier] of Object.entries(dependencies)) {
 			const requirement = getRequirement(lock, dependency, specifier);
 			const resolved = resolveDependencyLockKey(key, dependency, packages);
@@ -606,6 +608,63 @@ function mergeLockfiles(lock, nestedLock, dir) {
 		packages
 	};
 }
+/**
+* Gives the dependencies of the host root package back their previous host resolutions where top-level nested
+* entries do not satisfy them.
+*
+* Bun resolves the dependencies of the root package at the top level only, so placing the host resolution under the
+* root name does not pin the root dependency: the host resolution returns to the top level with its host chain instead.
+* Then every dependency of a nested workspace or package that no longer resolves to its nested entry or a copy of it,
+* such as one that resolved the replaced entry, gets a copy of its nested entry under the dependent,
+* so the copied entries keep their whole nested dependency trees.
+*/
+function keepHostRootResolutions(lock, nestedLock, packages) {
+	const replaced = /* @__PURE__ */ new Set();
+	for (const [dependency, specifier] of Object.entries(getWorkspaceDependencies(lock.workspaces[""]))) {
+		const requirement = getRequirement(lock, dependency, specifier);
+		const nestedEntry = Object.hasOwn(nestedLock.packages, dependency) ? nestedLock.packages[dependency] : void 0;
+		if (!requirement || !nestedEntry || satisfies(nestedEntry, requirement)) continue;
+		const previous = Object.hasOwn(lock.packages, dependency) ? lock.packages[dependency] : void 0;
+		const replacement = previous && satisfies(previous, requirement) ? previous : findSatisfyingEntry([nestedLock.packages, lock.packages], requirement);
+		if (!replacement) continue;
+		replaced.add(dependency);
+		const prefix = `${dependency}/`;
+		for (const key of Object.keys(packages)) if (key.startsWith(prefix)) delete packages[key];
+		packages[dependency] = replacement;
+		if (replacement === previous) {
+			for (const [key, entry] of Object.entries(lock.packages)) if (key.startsWith(prefix)) packages[key] = entry;
+		}
+	}
+	if (!replaced.size) return;
+	const nestedKeys = new Map(Object.keys(nestedLock.packages).filter((key) => !replaced.has(splitPackageKey(key)[0])).map((key) => [key, key]));
+	const queue = [...Object.values(nestedLock.workspaces).flatMap((workspace) => workspace.name ? [{
+		key: workspace.name,
+		nestedKey: workspace.name,
+		dependencies: getWorkspaceDependencies(workspace)
+	}] : []), ...[...nestedKeys.keys()].map((key) => ({
+		key,
+		nestedKey: key,
+		dependencies: getPackageDependencies(nestedLock.packages[key])
+	}))];
+	for (let index = 0; index < queue.length; index++) {
+		const { key, nestedKey, dependencies } = queue[index];
+		for (const dependency of Object.keys(dependencies)) {
+			const expected = resolveDependencyLockKey(nestedKey, dependency, nestedLock.packages);
+			if (expected === void 0) continue;
+			const actual = resolveDependencyLockKey(key, dependency, packages);
+			if (actual !== void 0 && nestedKeys.get(actual) === expected) continue;
+			const entry = nestedLock.packages[expected];
+			const pinnedKey = `${key}/${dependency}`;
+			packages[pinnedKey] = entry;
+			nestedKeys.set(pinnedKey, expected);
+			queue.push({
+				key: pinnedKey,
+				nestedKey: expected,
+				dependencies: getPackageDependencies(entry)
+			});
+		}
+	}
+}
 /** Returns the installed dependencies declared by a lockfile workspace. */
 function getWorkspaceDependencies(workspace) {
 	return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bun-nested-workspace",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "Embed a checkout of another Bun workspace repository into a Bun workspace and keep the root package.json and bun.lock in sync with it",
   "keywords": [
     "bun",