nx 19.7.0-canary.20240829-0ef6892 → 19.7.0-canary.20240831-18e5535

package/src/daemon/server/sync-generators.js

@@ -4,6 +4,7 @@ exports.getCachedSyncGeneratorChanges = getCachedSyncGeneratorChanges;
 exports.flushSyncGeneratorChangesToDisk = flushSyncGeneratorChangesToDisk;
 exports.collectAndScheduleSyncGenerators = collectAndScheduleSyncGenerators;
 exports.getCachedRegisteredSyncGenerators = getCachedRegisteredSyncGenerators;
+exports._getConflictingGeneratorGroups = _getConflictingGeneratorGroups;
 const nx_json_1 = require("../../config/nx-json");
 const tree_1 = require("../../generators/tree");
 const file_hasher_1 = require("../../hasher/file-hasher");
@@ -25,7 +26,6 @@ let storedDisabledTaskSyncGeneratorsHash;
 const log = (...messageParts) => {
     logger_1.serverLogger.log('[SYNC]:', ...messageParts);
 };
-// TODO(leo): check conflicts and reuse the Tree where possible
 async function getCachedSyncGeneratorChanges(generators) {
     try {
         log('get sync generators changes on demand', generators);
@@ -37,51 +37,15 @@ async function getCachedSyncGeneratorChanges(generators) {
         }
         // reset the wait time
         waitPeriod = 100;
-        let projects;
-        let errored = false;
-        const getProjectsConfigurations = async () => {
-            if (projects || errored) {
-                return projects;
-            }
-            const { projectGraph, error } = await (0, project_graph_incremental_recomputation_1.getCachedSerializedProjectGraphPromise)();
-            projects = projectGraph
-                ? (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph).projects
-                : null;
-            errored = error !== undefined;
-            return projects;
-        };
-        return (await Promise.all(generators.map(async (generator) => {
-            if (scheduledGenerators.has(generator) ||
-                !syncGeneratorsCacheResultPromises.has(generator)) {
-                // it's scheduled to run (there are pending changes to process) or
-                // it's not scheduled and there's no cached result, so run it
-                const projects = await getProjectsConfigurations();
-                if (projects) {
-                    log(generator, 'already scheduled or not cached, running it now');
-                    runGenerator(generator, projects);
-                }
-                else {
-                    log(generator, 'already scheduled or not cached, project graph errored');
-                    /**
-                     * This should never happen. This is invoked imperatively, and by
-                     * the time it is invoked, the project graph would have already
-                     * been requested. If it errored, it would have been reported and
-                     * this wouldn't have been invoked. We handle it just in case.
-                     *
-                     * Since the project graph would be reported by the relevant
-                     * handlers separately, we just ignore the error, don't cache
-                     * any result and return an empty result, the next time this is
-                     * invoked the process will repeat until it eventually recovers
-                     * when the project graph is fixed.
-                     */
-                    return Promise.resolve({ changes: [], generatorName: generator });
-                }
-            }
-            else {
-                log(generator, 'not scheduled and has cached result, returning cached result');
-            }
-            return syncGeneratorsCacheResultPromises.get(generator);
-        }))).flat();
+        const results = await getFromCacheOrRunGenerators(generators);
+        const conflicts = _getConflictingGeneratorGroups(results);
+        if (!conflicts.length) {
+            // there are no conflicts
+            return results;
+        }
+        // there are conflicts, so we need to re-run the conflicting generators
+        // using the same tree
+        return await processConflictingGenerators(conflicts, results);
     }
     catch (e) {
         console.error(e);
@@ -131,7 +95,7 @@ function collectAndScheduleSyncGenerators(projectGraph) {
         }
         const { projects } = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
         for (const generator of scheduledGenerators) {
-            runGenerator(generator, projects);
+            syncGeneratorsCacheResultPromises.set(generator, runGenerator(generator, projects));
         }
         await Promise.all(syncGeneratorsCacheResultPromises.values());
     }, waitPeriod);
@@ -148,6 +112,163 @@ async function getCachedRegisteredSyncGenerators() {
     }
     return [...registeredSyncGenerators];
 }
+async function getFromCacheOrRunGenerators(generators) {
+    let projects;
+    let errored = false;
+    const getProjectsConfigurations = async () => {
+        if (projects || errored) {
+            return projects;
+        }
+        const { projectGraph, error } = await (0, project_graph_incremental_recomputation_1.getCachedSerializedProjectGraphPromise)();
+        projects = projectGraph
+            ? (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph).projects
+            : null;
+        errored = error !== undefined;
+        return projects;
+    };
+    return (await Promise.all(generators.map(async (generator) => {
+        if (scheduledGenerators.has(generator) ||
+            !syncGeneratorsCacheResultPromises.has(generator)) {
+            // it's scheduled to run (there are pending changes to process) or
+            // it's not scheduled and there's no cached result, so run it
+            const projects = await getProjectsConfigurations();
+            if (projects) {
+                log(generator, 'already scheduled or not cached, running it now');
+                syncGeneratorsCacheResultPromises.set(generator, runGenerator(generator, projects));
+            }
+            else {
+                log(generator, 'already scheduled or not cached, project graph errored');
+                /**
+                 * This should never happen. This is invoked imperatively, and by
+                 * the time it is invoked, the project graph would have already
+                 * been requested. If it errored, it would have been reported and
+                 * this wouldn't have been invoked. We handle it just in case.
+                 *
+                 * Since the project graph would be reported by the relevant
+                 * handlers separately, we just ignore the error, don't cache
+                 * any result and return an empty result, the next time this is
+                 * invoked the process will repeat until it eventually recovers
+                 * when the project graph is fixed.
+                 */
+                return Promise.resolve({ changes: [], generatorName: generator });
+            }
+        }
+        else {
+            log(generator, 'not scheduled and has cached result, returning cached result');
+        }
+        return syncGeneratorsCacheResultPromises.get(generator);
+    }))).flat();
+}
+async function runConflictingGenerators(tree, generators) {
+    const { projectGraph } = await (0, project_graph_incremental_recomputation_1.getCachedSerializedProjectGraphPromise)();
+    const projects = projectGraph
+        ? (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph).projects
+        : null;
+    if (!projects) {
+        /**
+         * This should never happen. This is invoked imperatively, and by
+         * the time it is invoked, the project graph would have already
+         * been requested. If it errored, it would have been reported and
+         * this wouldn't have been invoked. We handle it just in case.
+         *
+         * Since the project graph would be reported by the relevant
+         * handlers separately, we just ignore the error.
+         */
+        return generators.map((generator) => ({
+            changes: [],
+            generatorName: generator,
+        }));
+    }
+    // we need to run conflicting generators sequentially because they use the same tree
+    const results = [];
+    for (const generator of generators) {
+        log(generator, 'running it now');
+        results.push(await runGenerator(generator, projects, tree));
+    }
+    return results;
+}
+async function processConflictingGenerators(conflicts, initialResults) {
+    const conflictRunResults = (await Promise.all(conflicts.map((generators) => {
+        const [firstGenerator, ...generatorsToRun] = generators;
+        // it must exists because the conflicts were identified from the initial results
+        const firstGeneratorResult = initialResults.find((r) => r.generatorName === firstGenerator);
+        const tree = new tree_1.FsTree(workspace_root_1.workspaceRoot, false, `running sync generators ${generators.join(',')}`);
+        // pre-apply the changes from the first generator to avoid running it
+        for (const change of firstGeneratorResult.changes) {
+            if (change.type === 'CREATE' || change.type === 'UPDATE') {
+                tree.write(change.path, change.content, change.options);
+            }
+            else if (change.type === 'DELETE') {
+                tree.delete(change.path);
+            }
+        }
+        /**
+         * We don't cache the results of conflicting generators because they
+         * use the same tree, so some files might contain results from multiple
+         * generators and we don't have guarantees that the same combination of
+         * generators will run together.
+         */
+        return runConflictingGenerators(tree, generatorsToRun);
+    }))).flat();
+    /**
+     * The order of the results from the re-run generators is important because
+     * the last result from a group of conflicting generators will contain the
+     * changes from the previous conflicting generators. So, instead of replacing
+     * in-place the initial results, we first add the results from the re-run
+     * generators, and then add the initial results that were not from a
+     * conflicting generator.
+     */
+    const results = [...conflictRunResults];
+    for (const result of initialResults) {
+        if (conflictRunResults.every((r) => r.generatorName !== result.generatorName)) {
+            // this result is not from a conflicting generator, so we add it to the
+            // results
+            results.push(result);
+        }
+    }
+    return results;
+}
+/**
+ * @internal
+ */
+function _getConflictingGeneratorGroups(results) {
+    const changedFileToGeneratorMap = new Map();
+    for (const result of results) {
+        for (const change of result.changes) {
+            if (!changedFileToGeneratorMap.has(change.path)) {
+                changedFileToGeneratorMap.set(change.path, new Set());
+            }
+            changedFileToGeneratorMap.get(change.path).add(result.generatorName);
+        }
+    }
+    const conflicts = [];
+    for (const generatorSet of changedFileToGeneratorMap.values()) {
+        if (generatorSet.size === 1) {
+            // no conflicts
+            continue;
+        }
+        if (conflicts.length === 0) {
+            // there are no conflicts yet, so we just add the first group
+            conflicts.push(new Set(generatorSet));
+            continue;
+        }
+        // identify if any of the current generator sets intersect with any of the
+        // existing conflict groups
+        const generatorsArray = Array.from(generatorSet);
+        const existingConflictGroup = conflicts.find((group) => generatorsArray.some((generator) => group.has(generator)));
+        if (existingConflictGroup) {
+            // there's an intersecting group, so we merge the two
+            for (const generator of generatorsArray) {
+                existingConflictGroup.add(generator);
+            }
+        }
+        else {
+            // there's no intersecting group, so we create a new one
+            conflicts.push(new Set(generatorsArray));
+        }
+    }
+    return conflicts.map((group) => Array.from(group));
+}
 function collectAllRegisteredSyncGenerators(projectGraph) {
     const nxJson = (0, nx_json_1.readNxJson)();
     const projectGraphHash = hashProjectGraph(projectGraph);
@@ -191,16 +312,15 @@ function collectAllRegisteredSyncGenerators(projectGraph) {
         }
     }
 }
-function runGenerator(generator, projects) {
+function runGenerator(generator, projects, tree) {
     log('running scheduled generator', generator);
     // remove it from the scheduled set
     scheduledGenerators.delete(generator);
-    const tree = new tree_1.FsTree(workspace_root_1.workspaceRoot, false, `running sync generator ${generator}`);
-    // run the generator and cache the result
-    syncGeneratorsCacheResultPromises.set(generator, (0, sync_generators_1.runSyncGenerator)(tree, generator, projects).then((result) => {
+    tree ??= new tree_1.FsTree(workspace_root_1.workspaceRoot, false, `running sync generator ${generator}`);
+    return (0, sync_generators_1.runSyncGenerator)(tree, generator, projects).then((result) => {
         log(generator, 'changes:', result.changes.map((c) => c.path).join(', '));
         return result;
-    }));
+    });
 }
 function hashProjectGraph(projectGraph) {
     const stringifiedProjects = Object.entries(projectGraph.nodes)

package/src/nx-cloud/generators/connect-to-nx-cloud/connect-to-nx-cloud.d.ts

@@ -7,7 +7,8 @@ export interface ConnectToNxCloudOptions {
     hideFormatLogs?: boolean;
     github?: boolean;
     directory?: string;
+    generateToken?: boolean;
 }
-export declare function connectToNxCloud(tree: Tree, schema: ConnectToNxCloudOptions, nxJson?: NxJsonConfiguration<string[] | "*">): Promise<string>;
+export declare function connectToNxCloud(tree: Tree, schema: ConnectToNxCloudOptions, nxJson?: NxJsonConfiguration<string[] | "*">): Promise<string | null>;
 declare function connectToNxCloudGenerator(tree: Tree, options: ConnectToNxCloudOptions): Promise<void>;
 export default connectToNxCloudGenerator;

package/src/nx-cloud/generators/connect-to-nx-cloud/connect-to-nx-cloud.js

@@ -88,20 +88,22 @@ async function connectToNxCloud(tree, schema, nxJson = (0, nx_json_1.readNxJson)
         printCloudConnectionDisabledMessage();
         return null;
     }
-    else {
-        const usesGithub = schema.github ?? (await (0, url_shorten_1.repoUsesGithub)(schema.github));
-        let responseFromCreateNxCloudWorkspaceV2;
-        // do NOT create Nx Cloud token (createNxCloudWorkspace)
-        // if user is using github and is running nx-connect
-        if (!(usesGithub && schema.installationSource === 'nx-connect')) {
-            responseFromCreateNxCloudWorkspaceV2 = await createNxCloudWorkspaceV2(getRootPackageName(tree), schema.installationSource, getNxInitDate());
-            addNxCloudIdToNxJson(tree, responseFromCreateNxCloudWorkspaceV2?.nxCloudId, schema.directory);
-            await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree, {
-                silent: schema.hideFormatLogs,
-            });
-            return responseFromCreateNxCloudWorkspaceV2.nxCloudId;
-        }
-    }
+    const isGitHubDetected = schema.github ?? (await (0, url_shorten_1.repoUsesGithub)(schema.github));
+    let responseFromCreateNxCloudWorkspaceV2;
+    /**
+     * Do not create an Nx Cloud token if the user is using GitHub and
+     * is running `nx-connect` AND `token` is undefined (override)
+     */
+    if (!schema.generateToken &&
+        isGitHubDetected &&
+        schema.installationSource === 'nx-connect')
+        return null;
+    responseFromCreateNxCloudWorkspaceV2 = await createNxCloudWorkspaceV2(getRootPackageName(tree), schema.installationSource, getNxInitDate());
+    addNxCloudIdToNxJson(tree, responseFromCreateNxCloudWorkspaceV2?.nxCloudId, schema.directory);
+    await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree, {
+        silent: schema.hideFormatLogs,
+    });
+    return responseFromCreateNxCloudWorkspaceV2.nxCloudId;
 }
 async function connectToNxCloudGenerator(tree, options) {
     await connectToNxCloud(tree, options);

package/src/nx-cloud/generators/connect-to-nx-cloud/schema.json

@@ -21,6 +21,10 @@
       "description": "Hide formatting logs",
       "x-priority": "internal"
     },
+    "generateToken": {
+      "type": "boolean",
+      "description": "Explicitly asks for a token to be created, do not override existing tokens from Nx Cloud"
+    },
     "github": {
       "type": "boolean",
       "description": "If the user will be using GitHub as their git hosting provider",

package/src/utils/git-utils.d.ts

@@ -1,6 +1,6 @@
-import { ExecSyncOptions } from 'child_process';
-export declare function cloneFromUpstream(url: string, destination: string, { originName }?: {
+export declare function cloneFromUpstream(url: string, destination: string, { originName, depth }?: {
     originName: string;
+    depth?: number;
 }): Promise<GitRepository>;
 export declare class GitRepository {
     private directory;
@@ -8,12 +8,10 @@ export declare class GitRepository {
     constructor(directory: string);
     getGitRootPath(cwd: string): string;
     addFetchRemote(remoteName: string, branch: string): Promise<string>;
-    private execAsync;
     showStat(): Promise<string>;
     listBranches(): Promise<string[]>;
     getGitFiles(path: string): Promise<string[]>;
     reset(ref: string): Promise<string>;
-    squashLastTwoCommits(): Promise<string>;
     mergeUnrelatedHistories(ref: string, message: string): Promise<string>;
     fetch(remote: string, ref?: string): Promise<string>;
     checkout(branch: string, opts: {
@@ -25,14 +23,13 @@ export declare class GitRepository {
     commit(message: string): Promise<string>;
     amendCommit(): Promise<string>;
     deleteGitRemote(name: string): Promise<string>;
-    deleteBranch(branch: string): Promise<string>;
     addGitRemote(name: string, url: string): Promise<string>;
+    hasFilterRepoInstalled(): Promise<boolean>;
+    filterRepo(subdirectory: string): Promise<string>;
+    filterBranch(subdirectory: string, branchName: string): Promise<string>;
+    private execAsync;
+    private quotePath;
 }
-/**
- * This is used by the squash editor script to update the rebase file.
- */
-export declare function updateRebaseFile(contents: string): string;
-export declare function fetchGitRemote(name: string, branch: string, execOptions: ExecSyncOptions): string | Buffer;
 /**
  * This is currently duplicated in Nx Console. Please let @MaxKless know if you make changes here.
  */

package/src/utils/git-utils.js

@@ -2,16 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GitRepository = void 0;
 exports.cloneFromUpstream = cloneFromUpstream;
-exports.updateRebaseFile = updateRebaseFile;
-exports.fetchGitRemote = fetchGitRemote;
 exports.getGithubSlugOrNull = getGithubSlugOrNull;
 exports.extractUserAndRepoFromGitHubUrl = extractUserAndRepoFromGitHubUrl;
 exports.commitChanges = commitChanges;
 exports.getLatestCommitSha = getLatestCommitSha;
 const child_process_1 = require("child_process");
-const devkit_exports_1 = require("../devkit-exports");
 const path_1 = require("path");
-const SQUASH_EDITOR = (0, path_1.join)(__dirname, 'squash.js');
+const devkit_exports_1 = require("../devkit-exports");
 function execAsync(command, execOptions) {
     return new Promise((res, rej) => {
         (0, child_process_1.exec)(command, execOptions, (err, stdout, stderr) => {
@@ -22,9 +19,12 @@ function execAsync(command, execOptions) {
         });
     });
 }
-async function cloneFromUpstream(url, destination, { originName } = { originName: 'origin' }) {
-    await execAsync(`git clone ${url} ${destination} --depth 1 --origin ${originName}`, {
+async function cloneFromUpstream(url, destination, { originName, depth } = {
+    originName: 'origin',
+}) {
+    await execAsync(`git clone ${url} ${destination} ${depth ? `--depth ${depth}` : ''} --origin ${originName}`, {
         cwd: (0, path_1.dirname)(destination),
+        maxBuffer: 10 * 1024 * 1024,
     });
     return new GitRepository(destination);
 }
@@ -40,13 +40,8 @@ class GitRepository {
             .toString()
             .trim();
     }
-    addFetchRemote(remoteName, branch) {
-        return this.execAsync(`git config --add remote.${remoteName}.fetch "+refs/heads/${branch}:refs/remotes/${remoteName}/${branch}"`);
-    }
-    execAsync(command) {
-        return execAsync(command, {
-            cwd: this.root,
-        });
+    async addFetchRemote(remoteName, branch) {
+        return await this.execAsync(`git config --add remote.${remoteName}.fetch "+refs/heads/${branch}:refs/remotes/${remoteName}/${branch}"`);
     }
     async showStat() {
         return await this.execAsync(`git show --stat`);
@@ -61,62 +56,84 @@ class GitRepository {
             .replace('refs/heads/', ''));
     }
     async getGitFiles(path) {
-        return (await this.execAsync(`git ls-files ${path}`))
+        // Use -z to return file names exactly as they are stored in git, separated by NULL (\x00) character.
+        // This avoids problems with special characters in file names.
+        return (await this.execAsync(`git ls-files -z ${path}`))
             .trim()
-            .split('\n')
+            .split('\x00')
             .map((s) => s.trim())
             .filter(Boolean);
     }
     async reset(ref) {
-        return this.execAsync(`git reset ${ref} --hard`);
-    }
-    async squashLastTwoCommits() {
-        return this.execAsync(`git -c core.editor="node ${SQUASH_EDITOR}" rebase --interactive --no-autosquash HEAD~2`);
+        return await this.execAsync(`git reset ${ref} --hard`);
     }
     async mergeUnrelatedHistories(ref, message) {
-        return this.execAsync(`git merge ${ref} -X ours --allow-unrelated-histories -m "${message}"`);
+        return await this.execAsync(`git merge ${ref} -X ours --allow-unrelated-histories -m "${message}"`);
     }
     async fetch(remote, ref) {
-        return this.execAsync(`git fetch ${remote}${ref ? ` ${ref}` : ''}`);
+        return await this.execAsync(`git fetch ${remote}${ref ? ` ${ref}` : ''}`);
     }
     async checkout(branch, opts) {
-        return this.execAsync(`git checkout ${opts.new ? '-b ' : ' '}${branch}${opts.base ? ' ' + opts.base : ''}`);
+        return await this.execAsync(`git checkout ${opts.new ? '-b ' : ' '}${branch}${opts.base ? ' ' + opts.base : ''}`);
     }
     async move(path, destination) {
-        return this.execAsync(`git mv "${path}" "${destination}"`);
+        return await this.execAsync(`git mv ${this.quotePath(path)} ${this.quotePath(destination)}`);
     }
     async push(ref, remoteName) {
-        return this.execAsync(`git push -u -f ${remoteName} ${ref}`);
+        return await this.execAsync(`git push -u -f ${remoteName} ${ref}`);
     }
     async commit(message) {
-        return this.execAsync(`git commit -am "${message}"`);
+        return await this.execAsync(`git commit -am "${message}"`);
     }
     async amendCommit() {
-        return this.execAsync(`git commit --amend -a --no-edit`);
+        return await this.execAsync(`git commit --amend -a --no-edit`);
     }
-    deleteGitRemote(name) {
-        return this.execAsync(`git remote rm ${name}`);
+    async deleteGitRemote(name) {
+        return await this.execAsync(`git remote rm ${name}`);
     }
-    deleteBranch(branch) {
-        return this.execAsync(`git branch -D ${branch}`);
+    async addGitRemote(name, url) {
+        return await this.execAsync(`git remote add ${name} ${url}`);
+    }
+    async hasFilterRepoInstalled() {
+        try {
+            await this.execAsync(`git filter-repo --help`);
+            return true;
+        }
+        catch {
+            return false;
+        }
     }
-    addGitRemote(name, url) {
-        return this.execAsync(`git remote add ${name} ${url}`);
+    // git-filter-repo is much faster than filter-branch, but needs to be installed by user
+    // Use `hasFilterRepoInstalled` to check if it's installed
+    async filterRepo(subdirectory) {
+        // filter-repo requires POSIX path to work
+        const posixPath = subdirectory.split(path_1.sep).join(path_1.posix.sep);
+        return await this.execAsync(`git filter-repo -f --subdirectory-filter ${this.quotePath(posixPath)}`);
+    }
+    async filterBranch(subdirectory, branchName) {
+        // filter-repo requires POSIX path to work
+        const posixPath = subdirectory.split(path_1.sep).join(path_1.posix.sep);
+        // We need non-ASCII file names to not be quoted, or else filter-branch will exclude them.
+        await this.execAsync(`git config core.quotepath false`);
+        return await this.execAsync(`git filter-branch --subdirectory-filter ${this.quotePath(posixPath)} -- ${branchName}`);
+    }
+    execAsync(command) {
+        return execAsync(command, {
+            cwd: this.root,
+            maxBuffer: 10 * 1024 * 1024,
+        });
+    }
+    quotePath(path) {
+        return process.platform === 'win32'
+            ? // Windows/CMD only understands double-quotes, single-quotes are treated as part of the file name
+                // Bash and other shells will substitute `$` in file names with a variable value.
+                `"${path}"`
+            : // e.g. `git mv "$$file.txt" "libs/a/$$file.txt"` will not work since `$$` is swapped with the PID of the last process.
+                // Using single-quotes prevents this substitution.
+                `'${path}'`;
     }
 }
 exports.GitRepository = GitRepository;
-/**
- * This is used by the squash editor script to update the rebase file.
- */
-function updateRebaseFile(contents) {
-    const lines = contents.split('\n');
-    const lastCommitIndex = lines.findIndex((line) => line === '') - 1;
-    lines[lastCommitIndex] = lines[lastCommitIndex].replace('pick', 'fixup');
-    return lines.join('\n');
-}
-function fetchGitRemote(name, branch, execOptions) {
-    return (0, child_process_1.execSync)(`git fetch ${name} ${branch} --depth 1`, execOptions);
-}
 /**
  * This is currently duplicated in Nx Console. Please let @MaxKless know if you make changes here.
  */

package/src/utils/sync-generators.d.ts

@@ -3,7 +3,7 @@ import { type NxJsonConfiguration } from '../config/nx-json';
 import type { ProjectGraph } from '../config/project-graph';
 import type { TaskGraph } from '../config/task-graph';
 import type { ProjectConfiguration } from '../config/workspace-json-project-json';
-import { FsTree, type FileChange, type Tree } from '../generators/tree';
+import { type FileChange, type Tree } from '../generators/tree';
 export type SyncGeneratorResult = void | {
     callback?: GeneratorCallback;
     outOfSyncMessage?: string;
@@ -18,7 +18,7 @@ export type SyncGeneratorChangesResult = {
 export declare function getSyncGeneratorChanges(generators: string[]): Promise<SyncGeneratorChangesResult[]>;
 export declare function flushSyncGeneratorChanges(results: SyncGeneratorChangesResult[]): Promise<void>;
 export declare function collectAllRegisteredSyncGenerators(projectGraph: ProjectGraph, nxJson: NxJsonConfiguration): Promise<string[]>;
-export declare function runSyncGenerator(tree: FsTree, generatorSpecifier: string, projects: Record<string, ProjectConfiguration>): Promise<SyncGeneratorChangesResult>;
+export declare function runSyncGenerator(tree: Tree, generatorSpecifier: string, projects: Record<string, ProjectConfiguration>): Promise<SyncGeneratorChangesResult>;
 export declare function collectEnabledTaskSyncGeneratorsFromProjectGraph(projectGraph: ProjectGraph, nxJson: NxJsonConfiguration): Set<string>;
 export declare function collectEnabledTaskSyncGeneratorsFromTaskGraph(taskGraph: TaskGraph, projectGraph: ProjectGraph, nxJson: NxJsonConfiguration): Set<string>;
 export declare function collectRegisteredGlobalSyncGenerators(nxJson?: NxJsonConfiguration<string[] | "*">): Set<string>;

package/src/utils/squash.d.ts

@@ -1 +0,0 @@
-export {};

package/src/utils/squash.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs_1 = require("fs");
-const git_utils_1 = require("./git-utils");
-// This script is used as an editor for git rebase -i
-// This is the file which git creates. When this script exits, the updates should be written to this file.
-const filePath = process.argv[2];
-// Change the second commit from pick to fixup
-const contents = (0, fs_1.readFileSync)(filePath).toString();
-const newContents = (0, git_utils_1.updateRebaseFile)(contents);
-// Write the updated contents back to the file
-(0, fs_1.writeFileSync)(filePath, newContents);