release-please 12.5.0 → 13.0.0-candidate.2

package/build/src/plugins/node-workspace.js

@@ -13,17 +13,19 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
-const semver = require("semver");
-const cu = require("@lerna/collect-updates");
-const package_1 = require("@lerna/package");
+exports.NodeWorkspace = void 0;
 const package_graph_1 = require("@lerna/package-graph");
-const run_topologically_1 = require("@lerna/run-topologically");
-const plugin_1 = require("./plugin");
+const package_1 = require("@lerna/package");
+const logger_1 = require("../util/logger");
+const manifest_1 = require("../manifest");
+const version_1 = require("../version");
+const raw_content_1 = require("../updaters/raw-content");
+const pull_request_title_1 = require("../util/pull-request-title");
+const pull_request_body_1 = require("../util/pull-request-body");
+const branch_name_1 = require("../util/branch-name");
 const json_stringify_1 = require("../util/json-stringify");
-const checkpoint_1 = require("../util/checkpoint");
-const constants_1 = require("../constants");
-const conventional_commits_1 = require("../conventional-commits");
 const changelog_1 = require("../updaters/changelog");
+const workspace_1 = require("./workspace");
 class Package extends package_1.Package {
     constructor(rawContent, location, pkg) {
         super(pkg !== null && pkg !== void 0 ? pkg : JSON.parse(rawContent), location);
@@ -33,301 +35,262 @@ class Package extends package_1.Package {
         return new Package(this.rawContent, this.location, this.toJSON());
     }
 }
-class NodeWorkspaceDependencyUpdates extends plugin_1.ManifestPlugin {
-    // package.json contents already updated by the node releasers.
-    filterPackages(pkgsWithPRData) {
-        const pathPkgs = new Map();
-        for (const pkg of pkgsWithPRData) {
-            if (pkg.config.releaseType === 'node' && pkg.config.path !== '.') {
-                for (const [path, fileData] of pkg.prData.changes) {
-                    if (path === `${pkg.config.path}/package.json`) {
-                        this.log(`found ${path} in changes`, checkpoint_1.CheckpointType.Success);
-                        pathPkgs.set(path, fileData.content);
-                    }
-                }
-            }
-        }
-        return pathPkgs;
+/**
+ * The plugin analyzed a cargo workspace and will bump dependencies
+ * of managed packages if those dependencies are being updated.
+ *
+ * If multiple node packages are being updated, it will merge them
+ * into a single node package.
+ */
+class NodeWorkspace extends workspace_1.WorkspacePlugin {
+    constructor(github, targetBranch, repositoryConfig, options = {}) {
+        super(github, targetBranch, repositoryConfig, options);
+        this.alwaysLinkLocal = options.alwaysLinkLocal === false ? false : true;
     }
-    // all packages' package.json content - both updated by this run as well as
-    // those that did not update (no user facing commits).
-    async getAllWorkspacePackages(rpUpdatedPkgs) {
-        const nodePkgs = new Map();
-        for (const pkg of this.config.parsedPackages) {
-            if (pkg.releaseType !== 'node' || pkg.path === '.') {
+    async buildAllPackages(candidates) {
+        const candidatesByPath = new Map();
+        for (const candidate of candidates) {
+            candidatesByPath.set(candidate.path, candidate);
+        }
+        const candidatesByPackage = {};
+        const packagesByPath = new Map();
+        for (const path in this.repositoryConfig) {
+            const config = this.repositoryConfig[path];
+            if (config.releaseType !== 'node') {
                 continue;
             }
-            const path = `${pkg.path}/package.json`;
-            let contents;
-            const alreadyUpdated = rpUpdatedPkgs.get(path);
-            if (alreadyUpdated) {
-                contents = alreadyUpdated;
+            const candidate = candidatesByPath.get(path);
+            if (candidate) {
+                logger_1.logger.debug(`Found candidate pull request for path: ${candidate.path}`);
+                const packagePath = addPath(candidate.path, 'package.json');
+                const packageUpdate = candidate.pullRequest.updates.find(update => update.path === packagePath);
+                if (packageUpdate === null || packageUpdate === void 0 ? void 0 : packageUpdate.cachedFileContents) {
+                    const pkg = new Package(packageUpdate.cachedFileContents.parsedContent, candidate.path);
+                    packagesByPath.set(candidate.path, pkg);
+                    candidatesByPackage[pkg.name] = candidate;
+                }
+                else {
+                    const contents = await this.github.getFileContentsOnBranch(packagePath, this.targetBranch);
+                    const pkg = new Package(contents.parsedContent, candidate.path);
+                    packagesByPath.set(candidate.path, pkg);
+                    candidatesByPackage[pkg.name] = candidate;
+                }
             }
             else {
-                const { parsedContent } = await this.gh.getFileContents(path);
-                contents = parsedContent;
+                const packagePath = addPath(path, 'package.json');
+                logger_1.logger.debug(`No candidate pull request for path: ${path} - inspect package from ${packagePath}`);
+                const contents = await this.github.getFileContentsOnBranch(packagePath, this.targetBranch);
+                packagesByPath.set(path, new Package(contents.parsedContent, path));
             }
-            this.log(`loaded ${path} from ${alreadyUpdated ? 'existing changes' : 'github'}`, checkpoint_1.CheckpointType.Success);
-            nodePkgs.set(path, new Package(contents, path));
         }
-        return nodePkgs;
+        const allPackages = Array.from(packagesByPath.values());
+        this.packageGraph = new package_graph_1.PackageGraph(allPackages, 'allDependencies', this.alwaysLinkLocal);
+        return {
+            allPackages,
+            candidatesByPackage,
+        };
+    }
+    bumpVersion(pkg) {
+        const version = version_1.Version.parse(pkg.version);
+        version.patch += 1;
+        return version;
     }
-    async runLernaVersion(rpUpdatedPkgs, allPkgs) {
+    updateCandidate(existingCandidate, pkg, updatedVersions) {
         var _a;
-        // Build the graph of all the packages: similar to https://git.io/Jqf1v
-        const packageGraph = new package_graph_1.PackageGraph(
-        // use pkg.clone() which does a shallow copy of the internal data storage
-        // so we can preserve the original allPkgs for version diffing later.
-        [...allPkgs.values()].map(pkg => pkg.clone()), 'allDependencies', (_a = this.config['always-link-local']) !== null && _a !== void 0 ? _a : true);
-        // release-please already did the work of @lerna/collectUpdates (identifying
-        // which packages need version bumps based on conventional commits). We use
-        // that as our `isCandidate` callback in @lerna/collectUpdates.collectPackages.
-        // similar to https://git.io/JqUOB
-        // `collectPackages` includes "localDependents" of our release-please updated
-        // packages as they need to be patch bumped.
-        const isCandidate = (node) => rpUpdatedPkgs.has(node.location);
-        const updatesWithDependents = cu.collectPackages(packageGraph, {
-            isCandidate,
-            onInclude: name => this.log(`${name} collected for update (dependency-only = ${!isCandidate(packageGraph.get(name))})`, checkpoint_1.CheckpointType.Success),
-            excludeDependents: false,
-        });
-        // our implementation of producing a Map<pkgName, newVersion> similar to
-        // `this.updatesVersions` which is used to set updated package
-        // (https://git.io/JqfD7) and dependency (https://git.io/JqU3q) versions
-        //
-        // `lerna version` accomplishes this with:
-        // `getVersionsForUpdates` (https://git.io/JqfyI)
-        //   -> `getVersion` + `reduceVersions` (https://git.io/JqfDI)
-        const updatesVersions = new Map();
-        const invalidVersions = new Set();
-        for (const node of updatesWithDependents) {
-            let version;
-            let source;
-            if (rpUpdatedPkgs.has(node.location)) {
-                version = node.version;
-                source = constants_1.RELEASE_PLEASE;
+        const graphPackage = (_a = this.packageGraph) === null || _a === void 0 ? void 0 : _a.get(pkg.name);
+        if (!graphPackage) {
+            throw new Error(`Could not find graph package for ${pkg.name}`);
+        }
+        const updatedPackage = pkg.clone();
+        for (const [depName, resolved] of graphPackage.localDependencies) {
+            const depVersion = updatedVersions.get(depName);
+            if (depVersion && resolved.type !== 'directory') {
+                updatedPackage.updateLocalDependency(resolved, depVersion.toString(), '^');
+                logger_1.logger.info(`${pkg.name}.${depName} updated to ^${depVersion.toString()}`);
             }
-            else {
-                // must be a dependent, check for releaseAs config otherwise default
-                // to a patch bump.
-                const pkgConfig = this.config.parsedPackages.find(p => {
-                    const pkgPath = `${p.path}/package.json`;
-                    const match = pkgPath === node.location;
-                    this.log(`Checking node "${node.location}" against parsed package "${pkgPath}"`, match ? checkpoint_1.CheckpointType.Success : checkpoint_1.CheckpointType.Failure);
-                    return match;
-                });
-                if (!pkgConfig) {
-                    this.log(`No pkgConfig found for ${node.location}`, checkpoint_1.CheckpointType.Failure);
-                }
-                else if (!pkgConfig.releaseAs) {
-                    this.log(`No pkgConfig.releaseAs for ${node.location}`, checkpoint_1.CheckpointType.Failure);
+        }
+        const dependencyNotes = getChangelogDepsNotes(pkg, updatedPackage);
+        existingCandidate.pullRequest.updates =
+            existingCandidate.pullRequest.updates.map(update => {
+                if (update.path === addPath(existingCandidate.path, 'package.json')) {
+                    update.updater = new raw_content_1.RawContent(json_stringify_1.jsonStringify(updatedPackage.toJSON(), updatedPackage.rawContent));
                 }
-                if (pkgConfig === null || pkgConfig === void 0 ? void 0 : pkgConfig.releaseAs) {
-                    version = pkgConfig.releaseAs;
-                    source = 'release-as configuration';
-                }
-                else {
-                    const patch = semver.inc(node.version, 'patch');
-                    if (patch === null) {
-                        this.log(`Don't know how to patch ${node.name}'s version(${node.version})`, checkpoint_1.CheckpointType.Failure);
-                        invalidVersions.add(node.name);
-                        version = node.version;
-                        source = 'failed to patch bump';
-                    }
-                    else {
-                        version = patch;
-                        source = 'dependency bump';
-                    }
+                else if (update.updater instanceof changelog_1.Changelog) {
+                    update.updater.changelogEntry = appendDependenciesSectionToChangelog(update.updater.changelogEntry, dependencyNotes);
                 }
+                return update;
+            });
+        // append dependency notes
+        if (dependencyNotes) {
+            if (existingCandidate.pullRequest.body.releaseData.length > 0) {
+                existingCandidate.pullRequest.body.releaseData[0].notes =
+                    appendDependenciesSectionToChangelog(existingCandidate.pullRequest.body.releaseData[0].notes, dependencyNotes);
             }
-            this.log(`setting ${node.location} to ${version} from ${source}`, checkpoint_1.CheckpointType.Success);
-            updatesVersions.set(node.name, version);
-        }
-        // our implementation of a subset of `updatePackageVersions` to produce a
-        // callback for updating versions and dependencies (https://git.io/Jqfyu)
-        const runner = async (pkg) => {
-            pkg.set('version', updatesVersions.get(pkg.name));
-            const graphPkg = packageGraph.get(pkg.name);
-            for (const [depName, resolved] of graphPkg.localDependencies) {
-                const depVersion = updatesVersions.get(depName);
-                if (depVersion && resolved.type !== 'directory') {
-                    pkg.updateLocalDependency(resolved, depVersion, '^');
-                    this.log(`${pkg.name}.${depName} updated to ^${depVersion}`, checkpoint_1.CheckpointType.Success);
-                }
+            else {
+                existingCandidate.pullRequest.body.releaseData.push({
+                    component: updatedPackage.name,
+                    version: existingCandidate.pullRequest.version,
+                    notes: appendDependenciesSectionToChangelog('', dependencyNotes),
+                });
             }
-            return pkg;
-        };
-        // https://git.io/Jqfyp
-        const allUpdated = (await run_topologically_1.runTopologically(updatesWithDependents.map(node => node.pkg), runner, {
-            graphType: 'allDependencies',
-            concurrency: 1,
-            rejectCycles: false,
-        }));
-        return new Map(allUpdated.map(p => [p.location, p]));
+        }
+        return existingCandidate;
     }
-    async updatePkgsWithPRData(pkgsWithPRData, newManifestVersions, allUpdated, allOrigPkgs) {
-        // already had version bumped by release-please, may have also had
-        // dependency version bumps as well
-        for (const data of pkgsWithPRData) {
-            if (data.config.releaseType !== 'node' || data.config.path === '.') {
-                continue;
+    newCandidate(pkg, updatedVersions) {
+        var _a;
+        const graphPackage = (_a = this.packageGraph) === null || _a === void 0 ? void 0 : _a.get(pkg.name);
+        if (!graphPackage) {
+            throw new Error(`Could not find graph package for ${pkg.name}`);
+        }
+        const updatedPackage = pkg.clone();
+        for (const [depName, resolved] of graphPackage.localDependencies) {
+            const depVersion = updatedVersions.get(depName);
+            if (depVersion && resolved.type !== 'directory') {
+                updatedPackage.updateLocalDependency(resolved, depVersion.toString(), '^');
+                logger_1.logger.info(`${pkg.name}.${depName} updated to ^${depVersion.toString()}`);
             }
-            const filePath = `${data.config.path}/package.json`;
-            const updated = allUpdated.get(filePath); // bug if not defined
-            data.prData.changes.set(filePath, {
-                content: json_stringify_1.jsonStringify(updated.toJSON(), updated.rawContent),
-                mode: '100644',
-            });
-            await this.setChangelogEntry(data.config, data.prData.changes, updated, allOrigPkgs.get(filePath).toJSON() // bug if undefined.
-            );
-            allUpdated.delete(filePath);
         }
-        // non-release-please updated packages that have updates solely because
-        // dependency versions incremented.
-        for (const [filePath, updated] of allUpdated) {
-            const pkg = this.config.parsedPackages.find(p => `${p.path}/package.json` === filePath); // bug if undefined.
-            pkg.packageName = updated.name;
-            const content = json_stringify_1.jsonStringify(updated.toJSON(), updated.rawContent);
-            const changes = new Map([[filePath, { content, mode: '100644' }]]);
-            await this.setChangelogEntry(pkg, changes, updated, allOrigPkgs.get(filePath) // bug if undefined.
-            );
-            pkgsWithPRData.push({
-                config: pkg,
-                prData: {
-                    version: updated.version,
-                    changes,
+        const dependencyNotes = getChangelogDepsNotes(pkg, updatedPackage);
+        const packageJson = updatedPackage.toJSON();
+        const version = version_1.Version.parse(packageJson.version);
+        const pullRequest = {
+            title: pull_request_title_1.PullRequestTitle.ofTargetBranch(this.targetBranch),
+            body: new pull_request_body_1.PullRequestBody([
+                {
+                    component: updatedPackage.name,
+                    version,
+                    notes: appendDependenciesSectionToChangelog('', dependencyNotes),
+                },
+            ]),
+            updates: [
+                {
+                    path: addPath(updatedPackage.location, 'package.json'),
+                    createIfMissing: false,
+                    updater: new raw_content_1.RawContent(json_stringify_1.jsonStringify(packageJson, updatedPackage.rawContent)),
+                },
+                {
+                    path: addPath(updatedPackage.location, 'CHANGELOG.md'),
+                    createIfMissing: false,
+                    updater: new changelog_1.Changelog({
+                        version,
+                        changelogEntry: dependencyNotes,
+                    }),
                 },
+            ],
+            labels: [],
+            headRefName: branch_name_1.BranchName.ofTargetBranch(this.targetBranch).toString(),
+            version,
+            draft: false,
+        };
+        return {
+            path: updatedPackage.location,
+            pullRequest,
+            config: {
+                releaseType: 'node',
+            },
+        };
+    }
+    async buildGraph(allPackages) {
+        var _a, _b, _c, _d;
+        const graph = new Map();
+        const workspacePackageNames = new Set(allPackages.map(packageJson => packageJson.name));
+        for (const packageJson of allPackages) {
+            const allDeps = Object.keys({
+                ...((_a = packageJson.dependencies) !== null && _a !== void 0 ? _a : {}),
+                ...((_b = packageJson.devDependencies) !== null && _b !== void 0 ? _b : {}),
+                ...((_c = packageJson.optionalDependencies) !== null && _c !== void 0 ? _c : {}),
+                ...((_d = packageJson.peerDependencies) !== null && _d !== void 0 ? _d : {}),
+            });
+            const workspaceDeps = allDeps.filter(dep => workspacePackageNames.has(dep));
+            graph.set(packageJson.name, {
+                deps: workspaceDeps,
+                value: packageJson,
             });
-            newManifestVersions.set(filePath.replace(/\/package.json$/, ''), updated.version);
         }
+        return graph;
     }
-    getChangelogDepsNotes(pkg, origPkgJson) {
-        var _a;
-        let depUpdateNotes = '';
-        const depTypes = [
-            'dependencies',
-            'devDependencies',
-            'peerDependencies',
-            'optionalDependencies',
-        ];
-        const updates = new Map();
-        for (const depType of depTypes) {
-            const depUpdates = [];
-            const pkgDepTypes = pkg[depType];
-            if (pkgDepTypes === undefined) {
-                continue;
-            }
-            for (const [depName, currentDepVer] of Object.entries(pkgDepTypes)) {
-                const origDepVer = (_a = origPkgJson[depType]) === null || _a === void 0 ? void 0 : _a[depName];
-                if (currentDepVer !== origDepVer) {
-                    depUpdates.push(`\n    * ${depName} bumped from ${origDepVer} to ${currentDepVer}`);
-                }
-            }
-            if (depUpdates.length > 0) {
-                updates.set(depType, depUpdates);
-            }
+    inScope(candidate) {
+        return (candidate.config.releaseType === 'node' &&
+            candidate.path !== manifest_1.ROOT_PROJECT_PATH);
+    }
+    packageNameFromPackage(pkg) {
+        return pkg.name;
+    }
+}
+exports.NodeWorkspace = NodeWorkspace;
+function getChangelogDepsNotes(original, updated) {
+    var _a;
+    let depUpdateNotes = '';
+    const depTypes = [
+        'dependencies',
+        'devDependencies',
+        'peerDependencies',
+        'optionalDependencies',
+    ];
+    const updates = new Map();
+    for (const depType of depTypes) {
+        const depUpdates = [];
+        const pkgDepTypes = updated[depType];
+        if (pkgDepTypes === undefined) {
+            continue;
         }
-        for (const [dt, notes] of updates) {
-            depUpdateNotes += `\n  * ${dt}`;
-            for (const note of notes) {
-                depUpdateNotes += note;
+        for (const [depName, currentDepVer] of Object.entries(pkgDepTypes)) {
+            const origDepVer = (_a = original[depType]) === null || _a === void 0 ? void 0 : _a[depName];
+            if (currentDepVer !== origDepVer) {
+                depUpdates.push(`\n    * ${depName} bumped from ${origDepVer} to ${currentDepVer}`);
             }
         }
-        return depUpdateNotes;
-    }
-    updateChangelogEntry(exChangelog, changelogEntry, pkg) {
-        changelogEntry = changelogEntry.replace(new RegExp(`^###? \\[${pkg.version}\\].*### Dependencies`, 's'), '### Dependencies');
-        const match = exChangelog.match(new RegExp(`(?<before>^.*?###? \\[${pkg.version}\\].*?\n)(?<after>###? [0-9[].*)`, 's'));
-        if (!match) {
-            this.log(`Appending update notes to end of changelog for ${pkg.name}`, checkpoint_1.CheckpointType.Failure);
-            changelogEntry = `${exChangelog}\n\n\n${changelogEntry}`;
-        }
-        else {
-            const { before, after } = match.groups;
-            changelogEntry = `${before.trim()}\n\n\n${changelogEntry}\n\n${after.trim()}`;
+        if (depUpdates.length > 0) {
+            updates.set(depType, depUpdates);
         }
-        return changelogEntry;
     }
-    async newChangelogEntry(changelogEntry, changelogPath, pkg) {
-        let changelog;
-        try {
-            changelog = (await this.gh.getFileContents(changelogPath)).parsedContent;
+    for (const [dt, notes] of updates) {
+        depUpdateNotes += `\n  * ${dt}`;
+        for (const note of notes) {
+            depUpdateNotes += note;
         }
-        catch (e) {
-            if (e.status !== 404) {
-                this.log(`Failed to retrieve ${changelogPath}: ${e}`, checkpoint_1.CheckpointType.Failure);
-                return '';
+    }
+    if (depUpdateNotes) {
+        return `* The following workspace dependencies were updated${depUpdateNotes}`;
+    }
+    return '';
+}
+const DEPENDENCY_HEADER = new RegExp('### Dependencies');
+function appendDependenciesSectionToChangelog(changelog, notes) {
+    if (!changelog) {
+        return `### Dependencies\n\n${notes}`;
+    }
+    const newLines = [];
+    let seenDependenciesSection = false;
+    let seenDependencySectionSpacer = false;
+    let injected = false;
+    for (const line of changelog.split('\n')) {
+        if (seenDependenciesSection) {
+            const trimmedLine = line.trim();
+            if (seenDependencySectionSpacer &&
+                !injected &&
+                !trimmedLine.startsWith('*')) {
+                newLines.push(changelog);
+                injected = true;
             }
-            else {
-                this.log(`Creating a new changelog at ${changelogPath}`, checkpoint_1.CheckpointType.Success);
+            if (trimmedLine === '') {
+                seenDependencySectionSpacer = true;
             }
         }
-        const changelogUpdater = new changelog_1.Changelog({
-            path: changelogPath,
-            changelogEntry,
-            version: pkg.version,
-            packageName: pkg.name,
-        });
-        return changelogUpdater.updateContent(changelog);
-    }
-    async setChangelogEntry(config, changes, pkg, origPkgJson) {
-        var _a, _b, _c;
-        const depUpdateNotes = this.getChangelogDepsNotes(pkg, origPkgJson);
-        if (!depUpdateNotes) {
-            return;
-        }
-        const cc = new conventional_commits_1.ConventionalCommits({
-            changelogSections: [{ type: 'deps', section: 'Dependencies' }],
-            commits: [
-                {
-                    sha: '',
-                    message: 'deps: The following workspace dependencies were updated',
-                    files: [],
-                },
-            ],
-            owner: this.gh.owner,
-            repository: this.gh.repo,
-            bumpMinorPreMajor: config.bumpMinorPreMajor,
-        });
-        let tagPrefix = ((_a = config.packageName) === null || _a === void 0 ? void 0 : _a.match(/^@[\w-]+\//)) ? config.packageName.split('/')[1]
-            : config.packageName;
-        tagPrefix += '-v';
-        let changelogEntry = await cc.generateChangelogEntry({
-            version: pkg.version,
-            currentTag: tagPrefix + pkg.version,
-            previousTag: tagPrefix + origPkgJson.version,
-        });
-        changelogEntry += depUpdateNotes;
-        let updatedChangelog;
-        let changelogPath = (_b = config.changelogPath) !== null && _b !== void 0 ? _b : 'CHANGELOG.md';
-        if (config.path !== '.') {
-            changelogPath = `${config.path}/${changelogPath}`;
-        }
-        const exChangelog = (_c = changes.get(changelogPath)) === null || _c === void 0 ? void 0 : _c.content;
-        if (exChangelog) {
-            updatedChangelog = this.updateChangelogEntry(exChangelog, changelogEntry, pkg);
-        }
-        else {
-            updatedChangelog = await this.newChangelogEntry(changelogEntry, changelogPath, pkg);
-        }
-        if (updatedChangelog) {
-            changes.set(changelogPath, {
-                content: updatedChangelog,
-                mode: '100644',
-            });
+        if (line.match(DEPENDENCY_HEADER)) {
+            seenDependenciesSection = true;
         }
+        newLines.push(line);
     }
-    /**
-     * Update node monorepo workspace package dependencies.
-     * Inspired by and using a subset of the logic from `lerna version`
-     */
-    async run(newManifestVersions, pkgsWithPRData) {
-        const rpUpdatedPkgs = this.filterPackages(pkgsWithPRData);
-        const allPkgs = await this.getAllWorkspacePackages(rpUpdatedPkgs);
-        const allUpdated = await this.runLernaVersion(rpUpdatedPkgs, allPkgs);
-        await this.updatePkgsWithPRData(pkgsWithPRData, newManifestVersions, allUpdated, allPkgs);
-        return [newManifestVersions, pkgsWithPRData];
+    if (injected) {
+        return newLines.join('\n');
     }
+    if (seenDependenciesSection) {
+        return `${changelog}\n${notes}`;
+    }
+    return `${changelog}\n\n\n### Dependencies\n\n${notes}`;
+}
+function addPath(path, file) {
+    return path === manifest_1.ROOT_PROJECT_PATH ? file : `${path}/${file}`;
 }
-exports.default = NodeWorkspaceDependencyUpdates;
 //# sourceMappingURL=node-workspace.js.map