@fluidframework/tree 2.0.0-dev-rc.1.0.0.224419

package/dist/core/rebase/utils.d.ts

@@ -0,0 +1,215 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { ChangeRebaser, RevisionInfo, RevisionMetadataSource, TaggedChange } from "./changeRebaser";
+import { GraphCommit } from "./types";
+/**
+ * Contains information about how the commit graph changed as the result of rebasing a source branch onto another target branch.
+ * @remarks
+ * ```text
+ * Consider the commit graph below containing two branches, X and Y, with head commits C and E, respectively.
+ * Branch Y branches off of Branch X at their common ancestor commit A, i.e. "Y is based off of X at commit A".
+ *
+ *   A ─ B ─ C ← Branch X
+ *   └─ D ─ E ← Branch Y
+ *
+ * Branch Y is then rebased onto Branch X. This results in the following commit graph:
+ *
+ *   A ─ B ─ C ← Branch X
+ *           └─ D'─ E'← Branch Y
+ *
+ * Commits D' and E' are the rebased versions of commits D and E, respectively. This results in:
+ * deletedSourceCommits: [D, E],
+ * targetCommits: [B, C],
+ * sourceCommits: [D', E']
+ * ```
+ */
+export interface RebasedCommits<TChange> {
+    /**
+     * The commits on the original source branch that were rebased. These are no longer referenced by the source branch and have
+     * been replaced with new versions on the new source branch, see {@link sourceCommits}. In the case that the source
+     * branch was already ahead of the target branch before the rebase, this list will be empty.
+     */
+    deletedSourceCommits: GraphCommit<TChange>[];
+    /**
+     * All commits on the target branch that the source branch's commits were rebased over. These are now the direct
+     * ancestors of {@link sourceCommits}. In the case that the source branch was already ahead of the target branch
+     * before the rebase, this list will be empty.
+     */
+    targetCommits: GraphCommit<TChange>[];
+    /**
+     * All commits on the source branch that are not also on the target branch after the rebase operation. In the case that the
+     * source branch was already ahead of the target branch before the rebase, these are the same commits that were already on
+     * the source branch before the rebase, otherwise these are the new, rebased versions of {@link deletedSourceCommits}.
+     */
+    sourceCommits: GraphCommit<TChange>[];
+}
+export interface BranchRebaseResult<TChange> {
+    /**
+     * The head of a rebased source branch.
+     */
+    readonly newSourceHead: GraphCommit<TChange>;
+    /**
+     * A thunk that computes the cumulative change to the source branch (undefined if no change occurred)
+     */
+    readonly sourceChange: TChange | undefined;
+    /**
+     * Details about how the commits on the source branch changed
+     */
+    readonly commits: RebasedCommits<TChange>;
+}
+/**
+ * Rebases a source branch onto another commit in a target branch.
+ *
+ * A "branch" is defined as a "head" commit and all ancestors of that commit, i.e. one linked list in a graph of commits.
+ *
+ * The source and target branch must share an ancestor.
+ * @param changeRebaser - the change rebaser responsible for rebasing the changes in the commits of each branch
+ * @param sourceHead - the head of the source branch, which will be rebased onto `targetHead`
+ * @param targetHead - the commit to rebase the source branch onto
+ * @returns a {@link BranchRebaseResult}
+ * @remarks While a single branch must not have multiple commits with the same revision tag (that will result in undefined
+ * behavior), there may be a commit on the source branch with the same revision tag as a commit on the target branch. If such
+ * a pair is encountered while rebasing, it will be "cancelled out" in the new branch. For example:
+ * ```
+ * // (A)-(B)-(C) <- Branch X
+ * //   \
+ * //   (B')-(D) <- Branch Y
+ * //
+ * // As Branch Y is rebased onto Branch X, commits B and B' cancel out so there is no version of B on the new rebased source branch
+ * //
+ * // (A)-(B)-(C) <- Branch X
+ * //           \
+ * //           (D') <- Branch Y'
+ * //
+ * ```
+ */
+export declare function rebaseBranch<TChange>(changeRebaser: ChangeRebaser<TChange>, sourceHead: GraphCommit<TChange>, targetHead: GraphCommit<TChange>): BranchRebaseResult<TChange>;
+/**
+ * Rebases a source branch onto another commit in a target branch.
+ *
+ * A "branch" is defined as a "head" commit and all ancestors of that commit, i.e. one linked list in a graph of commits.
+ *
+ * The source and target branch must share an ancestor.
+ * @param changeRebaser - the change rebaser responsible for rebasing the changes in the commits of each branch
+ * @param sourceHead - the head of the source branch, which will be rebased onto `newBase`
+ * @param targetCommit - the commit on the target branch to rebase the source branch onto.
+ * @param targetHead - the head of the branch that `newBase` belongs to. Must be `newBase` or a descendent of `newBase`.
+ * @returns a {@link BranchRebaseResult}
+ * @remarks While a single branch must not have multiple commits with the same revision tag (that will result in undefined
+ * behavior), there may be a commit on the source branch with the same revision tag as a commit on the target branch. If such
+ * a pair is encountered while rebasing, it will be "cancelled out" in the new branch. Additionally, this function will rebase
+ * the source branch _farther_ than `newBase` if the source branch's next commits after `newBase` match those on the target branch.
+ * For example:
+ * ```
+ * // (A)-(B)-(C)-(D)-(E) <- Branch X
+ * //   \
+ * //   (B')-(D')-(F) <- Branch Y
+ * //
+ * // If Branch Y is rebased onto commit C of Branch X, the branches must at least look like this afterwards (B was cancelled out):
+ * //
+ * // (A)-(B)-(C)-(D)-(E) <- Branch X
+ * //           \
+ * //           (D'')-(F') <- Branch Y'
+ * //
+ * // But this function will recognize that B is equivalent to B' and D is equivalent to D', and instead produce:
+ * //
+ * // (A)-(B)-(C)-(D)-(E) <- Branch X
+ * //               \
+ * //               (F') <- Branch Y'
+ * ```
+ */
+export declare function rebaseBranch<TChange>(changeRebaser: ChangeRebaser<TChange>, sourceHead: GraphCommit<TChange>, targetCommit: GraphCommit<TChange>, targetHead: GraphCommit<TChange>): BranchRebaseResult<TChange>;
+/**
+ * "Sandwich/Horseshoe Rebase" a change over the given source and target branches
+ * @param changeRebaser - the change rebaser responsible for rebasing the change over the commits in each branch
+ * @param change - the change to rebase
+ * @param sourceHead - the head of the branch that `change` is based on
+ * @param targetHead - the branch to rebase `change` onto
+ * @returns the rebased change
+ *
+ * @remarks inverses will be cached.
+ */
+export declare function rebaseChange<TChange>(changeRebaser: ChangeRebaser<TChange>, change: TChange, sourceHead: GraphCommit<TChange>, targetHead: GraphCommit<TChange>): TChange;
+/**
+ * @internal
+ */
+export declare function revisionMetadataSourceFromInfo(revInfos: readonly RevisionInfo[]): RevisionMetadataSource;
+export declare function rebaseChangeOverChanges<TChange>(changeRebaser: ChangeRebaser<TChange>, changeToRebase: TChange, changesToRebaseOver: TaggedChange<TChange>[]): TChange;
+/**
+ * Find the furthest ancestor of some descendant.
+ * @param descendant - a descendant. If an empty `path` array is included, it will be populated
+ * with the chain of ancestry for `descendant` from most distant to closest (not including the furthest ancestor,
+ * but otherwise including `descendant`).
+ * @returns the furthest ancestor of `descendant`, or `descendant` itself if `descendant` has no ancestors.
+ */
+export declare function findAncestor<T extends {
+    parent?: T;
+}>(descendant: T | [descendant: T, path?: T[]]): T;
+/**
+ * Find the furthest ancestor of some descendant.
+ * @param descendant - a descendant. If an empty `path` array is included, it will be populated
+ * with the chain of ancestry for `descendant` from most distant to closest (not including the furthest ancestor,
+ * but otherwise including `descendant`).
+ * @returns the furthest ancestor of `descendant`, or `descendant` itself if `descendant` has no ancestors. Returns
+ * `undefined` if `descendant` is undefined.
+ */
+export declare function findAncestor<T extends {
+    parent?: T;
+}>(descendant: T | [descendant: T | undefined, path?: T[]] | undefined): T | undefined;
+/**
+ * Find an ancestor of some descendant.
+ * @param descendant - a descendant. If an empty `path` array is included, it will be populated
+ * with the chain of ancestry for `descendant` from most distant to closest (not including the ancestor found by `predicate`,
+ * but otherwise including `descendant`).
+ * @param predicate - a function which will be evaluated on every ancestor of `descendant` until it returns true.
+ * @returns the closest ancestor of `descendant` that satisfies `predicate`, or `undefined` if no such ancestor exists.
+ *
+ * @example
+ *
+ * ```typescript
+ * interface Parented {
+ *   id: string;
+ *   parent?: Parented;
+ * }
+ * const g = { id: "g" }; // Grandparent
+ * const p = { parent: g, id: "p" }; // Parent
+ * const c = { parent: p, id: "c" }; // Child
+ * const path: Parented[] = [];
+ * const ancestor = findAncestor<Parented>([c, path], (n) => n.id === "g");
+ * // ancestor === g
+ * // path === [p, c]
+ * ```
+ */
+export declare function findAncestor<T extends {
+    parent?: T;
+}>(descendant: T | [descendant: T | undefined, path?: T[]] | undefined, predicate: (t: T) => boolean): T | undefined;
+/**
+ * Find a common ancestor between two descendants that are linked by parent pointers.
+ * @param descendantA - a descendant. If an empty `path` array is included, it will be populated
+ * with the chain of commits from the ancestor to `descendantA` (not including the ancestor).
+ * @param descendantB - another descendant. If an empty `path` array is included, it will be populated
+ * with the chain of commits from the ancestor to `descendantB` (not including the ancestor).
+ * @returns the common ancestor of `descendantA` and `descendantB`, or `undefined` if no such ancestor exists.
+ *
+ * @example
+ *
+ * ```typescript
+ * interface Parented {
+ *   parent?: Parented;
+ * }
+ * const shared = {};
+ * const a = { parent: shared };
+ * const b1 = { parent: shared };
+ * const b2 = { parent: b1 };
+ * const pathB: Parented[] = []
+ * const ancestor = findCommonAncestor<Parented>(a, [b2, pathB]);
+ * // ancestor === shared
+ * // pathB === [b1, b2]
+ * ```
+ */
+export declare function findCommonAncestor<T extends {
+    parent?: T;
+}>(descendantA: T | [descendantA: T, path?: T[]] | undefined, descendantB: T | [descendantB: T, path?: T[]] | undefined): T | undefined;
+//# sourceMappingURL=utils.d.ts.map

package/dist/core/rebase/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/core/rebase/utils.ts"],"names":[],"mappings":"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"}

package/dist/core/rebase/utils.js

@@ -0,0 +1,297 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findCommonAncestor = exports.findAncestor = exports.rebaseChangeOverChanges = exports.revisionMetadataSourceFromInfo = exports.rebaseChange = exports.rebaseBranch = void 0;
+const core_utils_1 = require("@fluidframework/core-utils");
+const changeRebaser_1 = require("./changeRebaser");
+const types_1 = require("./types");
+function rebaseBranch(changeRebaser, sourceHead, targetCommit, targetHead = targetCommit) {
+    // Get both source and target as path arrays
+    const sourcePath = [];
+    const targetPath = [];
+    const ancestor = findCommonAncestor([sourceHead, sourcePath], [targetHead, targetPath]);
+    (0, core_utils_1.assert)(ancestor !== undefined, 0x675 /* branches must be related */);
+    // Find where `targetCommit` is in the target branch
+    const targetCommitIndex = targetPath.findIndex((r) => r === targetCommit);
+    if (targetCommitIndex === -1) {
+        // If the targetCommit is not in the target path, then it is either disjoint from `target` or it is behind/at
+        // the commit where source and target diverge (ancestor), in which case there is nothing more to rebase
+        // TODO: Ideally, this would be an "assertExpensive"
+        (0, core_utils_1.assert)(findCommonAncestor(targetCommit, targetHead) !== undefined, 0x676 /* target commit is not in target branch */);
+        return {
+            newSourceHead: sourceHead,
+            sourceChange: undefined,
+            commits: { deletedSourceCommits: [], targetCommits: [], sourceCommits: sourcePath },
+        };
+    }
+    // Iterate through the target path and look for commits that are also present on the source branch (i.e. they
+    // have matching tags). Each commit found in the target branch can be skipped when processing the source branch
+    // because it has already been rebased onto the target. In the case that one or more of these commits are present
+    // directly after `targetCommit`, then the new base can be advanced further without having to do any work.
+    const sourceSet = new Set(sourcePath.map((r) => r.revision));
+    let newBaseIndex = targetCommitIndex;
+    for (let i = 0; i < targetPath.length; i += 1) {
+        const { revision } = targetPath[i];
+        if (sourceSet.has(revision)) {
+            sourceSet.delete(revision);
+            newBaseIndex = Math.max(newBaseIndex, i);
+        }
+        else if (i > targetCommitIndex) {
+            break;
+        }
+    }
+    /** The commit on the target branch that the new source branch branches off of (i.e. the new common ancestor) */
+    const newBase = targetPath[newBaseIndex];
+    // Figure out how much of the trunk to start rebasing over.
+    const targetCommits = targetPath.slice(0, newBaseIndex + 1);
+    const deletedSourceCommits = [...sourcePath];
+    // If the source and target rebase path begin with a range that has all the same revisions, remove it; it is
+    // equivalent on both branches and doesn't need to be rebased.
+    const targetRebasePath = [...targetCommits];
+    const minLength = Math.min(sourcePath.length, targetRebasePath.length);
+    for (let i = 0; i < minLength; i++) {
+        if (sourcePath[0].revision === targetRebasePath[0].revision) {
+            sourcePath.shift();
+            targetRebasePath.shift();
+        }
+    }
+    const sourceCommits = [];
+    // If all commits that are about to be rebased over on the target branch already comprise the start of the source branch,
+    // are in the same order, and have no other commits interleaving them, then no rebasing needs to occur. Those commits can
+    // simply be removed from the source branch, and the remaining commits on the source branch are reparented off of the new
+    // base commit.
+    if (targetRebasePath.length === 0) {
+        for (const c of sourcePath) {
+            sourceCommits.push((0, types_1.mintCommit)(sourceCommits[sourceCommits.length - 1] ?? newBase, c));
+        }
+        return {
+            newSourceHead: sourceCommits[sourceCommits.length - 1] ?? newBase,
+            sourceChange: undefined,
+            commits: {
+                deletedSourceCommits,
+                targetCommits,
+                sourceCommits,
+            },
+        };
+    }
+    // For each source commit, rebase backwards over the inverses of any commits already rebased, and then
+    // rebase forwards over the rest of the commits up to the new base before advancing the new base.
+    let newHead = newBase;
+    const inverses = [];
+    for (const c of sourcePath) {
+        if (sourceSet.has(c.revision)) {
+            const change = rebaseChangeOverChanges(changeRebaser, c.change, [
+                ...inverses,
+                ...targetRebasePath,
+            ]);
+            newHead = {
+                revision: c.revision,
+                change,
+                parent: newHead,
+            };
+            sourceCommits.push(newHead);
+            targetRebasePath.push({ ...c, change });
+        }
+        inverses.unshift((0, changeRebaser_1.tagRollbackInverse)(changeRebaser.invert(c, true), (0, types_1.mintRevisionTag)(), c.revision));
+    }
+    let netChange;
+    return {
+        newSourceHead: newHead,
+        get sourceChange() {
+            if (netChange === undefined) {
+                netChange = changeRebaser.compose([...inverses, ...targetRebasePath]);
+            }
+            return netChange;
+        },
+        commits: {
+            deletedSourceCommits,
+            targetCommits,
+            sourceCommits,
+        },
+    };
+}
+exports.rebaseBranch = rebaseBranch;
+/**
+ * "Sandwich/Horseshoe Rebase" a change over the given source and target branches
+ * @param changeRebaser - the change rebaser responsible for rebasing the change over the commits in each branch
+ * @param change - the change to rebase
+ * @param sourceHead - the head of the branch that `change` is based on
+ * @param targetHead - the branch to rebase `change` onto
+ * @returns the rebased change
+ *
+ * @remarks inverses will be cached.
+ */
+function rebaseChange(changeRebaser, change, sourceHead, targetHead) {
+    const sourcePath = [];
+    const targetPath = [];
+    (0, core_utils_1.assert)(findCommonAncestor([sourceHead, sourcePath], [targetHead, targetPath]) !== undefined, 0x576 /* branch A and branch B must be related */);
+    const inverses = sourcePath.map((commit) => inverseFromCommit(changeRebaser, commit, true));
+    inverses.reverse();
+    return rebaseChangeOverChanges(changeRebaser, change, [...inverses, ...targetPath]);
+}
+exports.rebaseChange = rebaseChange;
+/**
+ * @internal
+ */
+function revisionMetadataSourceFromInfo(revInfos) {
+    const getIndex = (revision) => {
+        const index = revInfos.findIndex((revInfo) => revInfo.revision === revision);
+        return index >= 0 ? index : undefined;
+    };
+    const tryGetInfo = (revision) => {
+        if (revision === undefined) {
+            return undefined;
+        }
+        const index = getIndex(revision);
+        return index === undefined ? undefined : revInfos[index];
+    };
+    const hasRollback = (revision) => {
+        return revInfos.find((info) => info.rollbackOf === revision) !== undefined;
+    };
+    return { getIndex, tryGetInfo, hasRollback };
+}
+exports.revisionMetadataSourceFromInfo = revisionMetadataSourceFromInfo;
+function rebaseChangeOverChanges(changeRebaser, changeToRebase, changesToRebaseOver) {
+    const revisionMetadata = revisionMetadataSourceFromInfo(getRevInfoFromTaggedChanges(changesToRebaseOver));
+    return changesToRebaseOver.reduce((a, b) => changeRebaser.rebase(a, b, revisionMetadata), changeToRebase);
+}
+exports.rebaseChangeOverChanges = rebaseChangeOverChanges;
+// TODO: Deduplicate
+function getRevInfoFromTaggedChanges(changes) {
+    const revInfos = [];
+    for (const taggedChange of changes) {
+        revInfos.push(...revisionInfoFromTaggedChange(taggedChange));
+    }
+    return revInfos;
+}
+// TODO: Deduplicate
+function revisionInfoFromTaggedChange(taggedChange) {
+    const revInfos = [];
+    if (taggedChange.revision !== undefined) {
+        const info = { revision: taggedChange.revision };
+        if (taggedChange.rollbackOf !== undefined) {
+            info.rollbackOf = taggedChange.rollbackOf;
+        }
+        revInfos.push(info);
+    }
+    return revInfos;
+}
+function inverseFromCommit(changeRebaser, commit, cache) {
+    const inverse = commit.inverse ?? changeRebaser.invert(commit, true);
+    if (cache === true && commit.inverse === undefined) {
+        commit.inverse = inverse;
+    }
+    return (0, changeRebaser_1.tagRollbackInverse)(inverse, (0, types_1.mintRevisionTag)(), commit.revision);
+}
+function findAncestor(descendant, predicate = (t) => t.parent === undefined) {
+    let d;
+    let path;
+    if (Array.isArray(descendant)) {
+        [d, path] = descendant;
+    }
+    else {
+        d = descendant;
+    }
+    for (let cur = d; cur !== undefined; cur = cur.parent) {
+        if (predicate(cur)) {
+            path?.reverse();
+            return cur;
+        }
+        path?.push(cur);
+    }
+    if (path !== undefined) {
+        path.length = 0;
+    }
+    return undefined;
+}
+exports.findAncestor = findAncestor;
+/**
+ * Find a common ancestor between two descendants that are linked by parent pointers.
+ * @param descendantA - a descendant. If an empty `path` array is included, it will be populated
+ * with the chain of commits from the ancestor to `descendantA` (not including the ancestor).
+ * @param descendantB - another descendant. If an empty `path` array is included, it will be populated
+ * with the chain of commits from the ancestor to `descendantB` (not including the ancestor).
+ * @returns the common ancestor of `descendantA` and `descendantB`, or `undefined` if no such ancestor exists.
+ *
+ * @example
+ *
+ * ```typescript
+ * interface Parented {
+ *   parent?: Parented;
+ * }
+ * const shared = {};
+ * const a = { parent: shared };
+ * const b1 = { parent: shared };
+ * const b2 = { parent: b1 };
+ * const pathB: Parented[] = []
+ * const ancestor = findCommonAncestor<Parented>(a, [b2, pathB]);
+ * // ancestor === shared
+ * // pathB === [b1, b2]
+ * ```
+ */
+function findCommonAncestor(descendantA, descendantB) {
+    let a;
+    let b;
+    let pathA;
+    let pathB;
+    if (Array.isArray(descendantA)) {
+        [a, pathA] = descendantA;
+        (0, core_utils_1.assert)(pathA === undefined || pathA.length === 0, 0x578 /* Path A must be empty */);
+    }
+    else {
+        a = descendantA;
+    }
+    if (Array.isArray(descendantB)) {
+        [b, pathB] = descendantB;
+        (0, core_utils_1.assert)(pathB === undefined || pathB.length === 0, 0x579 /* Path B must be empty */);
+    }
+    else {
+        b = descendantB;
+    }
+    if (a === b) {
+        return a;
+    }
+    const reversePaths = () => {
+        pathA?.reverse();
+        pathB?.reverse();
+    };
+    const visited = new Set();
+    while (a !== undefined || b !== undefined) {
+        if (a !== undefined) {
+            if (visited.has(a)) {
+                if (pathB !== undefined) {
+                    pathB.length = pathB.findIndex((r) => Object.is(r, a));
+                }
+                reversePaths();
+                return a;
+            }
+            visited.add(a);
+            pathA?.push(a);
+            a = a.parent;
+        }
+        if (b !== undefined) {
+            if (visited.has(b)) {
+                if (pathA !== undefined) {
+                    pathA.length = pathA.findIndex((r) => Object.is(r, b));
+                }
+                reversePaths();
+                return b;
+            }
+            visited.add(b);
+            pathB?.push(b);
+            b = b.parent;
+        }
+    }
+    if (pathA !== undefined) {
+        pathA.length = 0;
+    }
+    if (pathB !== undefined) {
+        pathB.length = 0;
+    }
+    return undefined;
+}
+exports.findCommonAncestor = findCommonAncestor;
+//# sourceMappingURL=utils.js.map

package/dist/core/rebase/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/core/rebase/utils.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,2DAAoD;AAEpD,mDAMyB;AACzB,mCAAgF;AAmIhF,SAAgB,YAAY,CAC3B,aAAqC,EACrC,UAAgC,EAChC,YAAkC,EAClC,UAAU,GAAG,YAAY;IAEzB,4CAA4C;IAC5C,MAAM,UAAU,GAA2B,EAAE,CAAC;IAC9C,MAAM,UAAU,GAA2B,EAAE,CAAC;IAC9C,MAAM,QAAQ,GAAG,kBAAkB,CAAC,CAAC,UAAU,EAAE,UAAU,CAAC,EAAE,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC;IACxF,IAAA,mBAAM,EAAC,QAAQ,KAAK,SAAS,EAAE,KAAK,CAAC,8BAA8B,CAAC,CAAC;IAErE,oDAAoD;IACpD,MAAM,iBAAiB,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,YAAY,CAAC,CAAC;IAC1E,IAAI,iBAAiB,KAAK,CAAC,CAAC,EAAE;QAC7B,6GAA6G;QAC7G,uGAAuG;QACvG,oDAAoD;QACpD,IAAA,mBAAM,EACL,kBAAkB,CAAC,YAAY,EAAE,UAAU,CAAC,KAAK,SAAS,EAC1D,KAAK,CAAC,2CAA2C,CACjD,CAAC;QACF,OAAO;YACN,aAAa,EAAE,UAAU;YACzB,YAAY,EAAE,SAAS;YACvB,OAAO,EAAE,EAAE,oBAAoB,EAAE,EAAE,EAAE,aAAa,EAAE,EAAE,EAAE,aAAa,EAAE,UAAU,EAAE;SACnF,CAAC;KACF;IAED,6GAA6G;IAC7G,+GAA+G;IAC/G,iHAAiH;IACjH,0GAA0G;IAC1G,MAAM,SAAS,GAAG,IAAI,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;IAC7D,IAAI,YAAY,GAAG,iBAAiB,CAAC;IAErC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE;QAC9C,MAAM,EAAE,QAAQ,EAAE,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;QACnC,IAAI,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE;YAC5B,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;YAC3B,YAAY,GAAG,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC;SACzC;aAAM,IAAI,CAAC,GAAG,iBAAiB,EAAE;YACjC,MAAM;SACN;KACD;IAED,gHAAgH;IAChH,MAAM,OAAO,GAAG,UAAU,CAAC,YAAY,CAAC,CAAC;IACzC,2DAA2D;IAC3D,MAAM,aAAa,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC,EAAE,YAAY,GAAG,CAAC,CAAC,CAAC;IAC5D,MAAM,oBAAoB,GAAG,CAAC,GAAG,UAAU,CAAC,CAAC;IAE7C,4GAA4G;IAC5G,8DAA8D;IAC9D,MAAM,gBAAgB,GAAG,CAAC,GAAG,aAAa,CAAC,CAAC;IAC5C,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,MAAM,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAC;IACvE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,EAAE,CAAC,EAAE,EAAE;QACnC,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC,QAAQ,KAAK,gBAAgB,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;YAC5D,UAAU,CAAC,KAAK,EAAE,CAAC;YACnB,gBAAgB,CAAC,KAAK,EAAE,CAAC;SACzB;KACD;IAED,MAAM,aAAa,GAA2B,EAAE,CAAC;IAEjD,yHAAyH;IACzH,yHAAyH;IACzH,yHAAyH;IACzH,eAAe;IACf,IAAI,gBAAgB,CAAC,MAAM,KAAK,CAAC,EAAE;QAClC,KAAK,MAAM,CAAC,IAAI,UAAU,EAAE;YAC3B,aAAa,CAAC,IAAI,CAAC,IAAA,kBAAU,EAAC,aAAa,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC,CAAC,IAAI,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC;SACtF;QACD,OAAO;YACN,aAAa,EAAE,aAAa,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC,CAAC,IAAI,OAAO;YACjE,YAAY,EAAE,SAAS;YACvB,OAAO,EAAE;gBACR,oBAAoB;gBACpB,aAAa;gBACb,aAAa;aACb;SACD,CAAC;KACF;IAED,sGAAsG;IACtG,iGAAiG;IACjG,IAAI,OAAO,GAAG,OAAO,CAAC;IACtB,MAAM,QAAQ,GAA4B,EAAE,CAAC;IAC7C,KAAK,MAAM,CAAC,IAAI,UAAU,EAAE;QAC3B,IAAI,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE;YAC9B,MAAM,MAAM,GAAG,uBAAuB,CAAC,aAAa,EAAE,CAAC,CAAC,MAAM,EAAE;gBAC/D,GAAG,QAAQ;gBACX,GAAG,gBAAgB;aACnB,CAAC,CAAC;YACH,OAAO,GAAG;gBACT,QAAQ,EAAE,CAAC,CAAC,QAAQ;gBACpB,MAAM;gBACN,MAAM,EAAE,OAAO;aACf,CAAC;YACF,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAC5B,gBAAgB,CAAC,IAAI,CAAC,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;SACxC;QACD,QAAQ,CAAC,OAAO,CACf,IAAA,kCAAkB,EAAC,aAAa,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,IAAA,uBAAe,GAAE,EAAE,CAAC,CAAC,QAAQ,CAAC,CAChF,CAAC;KACF;IAED,IAAI,SAA8B,CAAC;IACnC,OAAO;QACN,aAAa,EAAE,OAAO;QACtB,IAAI,YAAY;YACf,IAAI,SAAS,KAAK,SAAS,EAAE;gBAC5B,SAAS,GAAG,aAAa,CAAC,OAAO,CAAC,CAAC,GAAG,QAAQ,EAAE,GAAG,gBAAgB,CAAC,CAAC,CAAC;aACtE;YACD,OAAO,SAAS,CAAC;QAClB,CAAC;QACD,OAAO,EAAE;YACR,oBAAoB;YACpB,aAAa;YACb,aAAa;SACb;KACD,CAAC;AACH,CAAC;AA1HD,oCA0HC;AAED;;;;;;;;;GASG;AACH,SAAgB,YAAY,CAC3B,aAAqC,EACrC,MAAe,EACf,UAAgC,EAChC,UAAgC;IAEhC,MAAM,UAAU,GAA2B,EAAE,CAAC;IAC9C,MAAM,UAAU,GAA2B,EAAE,CAAC;IAC9C,IAAA,mBAAM,EACL,kBAAkB,CAAC,CAAC,UAAU,EAAE,UAAU,CAAC,EAAE,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC,KAAK,SAAS,EACpF,KAAK,CAAC,2CAA2C,CACjD,CAAC;IAEF,MAAM,QAAQ,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,iBAAiB,CAAC,aAAa,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC;IAC5F,QAAQ,CAAC,OAAO,EAAE,CAAC;IACnB,OAAO,uBAAuB,CAAC,aAAa,EAAE,MAAM,EAAE,CAAC,GAAG,QAAQ,EAAE,GAAG,UAAU,CAAC,CAAC,CAAC;AACrF,CAAC;AAhBD,oCAgBC;AAED;;GAEG;AACH,SAAgB,8BAA8B,CAC7C,QAAiC;IAEjC,MAAM,QAAQ,GAAG,CAAC,QAAqB,EAAsB,EAAE;QAC9D,MAAM,KAAK,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,QAAQ,KAAK,QAAQ,CAAC,CAAC;QAC7E,OAAO,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACvC,CAAC,CAAC;IACF,MAAM,UAAU,GAAG,CAAC,QAAiC,EAA4B,EAAE;QAClF,IAAI,QAAQ,KAAK,SAAS,EAAE;YAC3B,OAAO,SAAS,CAAC;SACjB;QACD,MAAM,KAAK,GAAG,QAAQ,CAAC,QAAQ,CAAC,CAAC;QACjC,OAAO,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC1D,CAAC,CAAC;IAEF,MAAM,WAAW,GAAG,CAAC,QAAqB,EAAW,EAAE;QACtD,OAAO,QAAQ,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,UAAU,KAAK,QAAQ,CAAC,KAAK,SAAS,CAAC;IAC5E,CAAC,CAAC;IAEF,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,CAAC;AAC9C,CAAC;AApBD,wEAoBC;AAED,SAAgB,uBAAuB,CACtC,aAAqC,EACrC,cAAuB,EACvB,mBAA4C;IAE5C,MAAM,gBAAgB,GAAG,8BAA8B,CACtD,2BAA2B,CAAC,mBAAmB,CAAC,CAChD,CAAC;IAEF,OAAO,mBAAmB,CAAC,MAAM,CAChC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,gBAAgB,CAAC,EACtD,cAAc,CACd,CAAC;AACH,CAAC;AAbD,0DAaC;AAED,oBAAoB;AACpB,SAAS,2BAA2B,CAAC,OAAgC;IACpE,MAAM,QAAQ,GAAmB,EAAE,CAAC;IACpC,KAAK,MAAM,YAAY,IAAI,OAAO,EAAE;QACnC,QAAQ,CAAC,IAAI,CAAC,GAAG,4BAA4B,CAAC,YAAY,CAAC,CAAC,CAAC;KAC7D;IAED,OAAO,QAAQ,CAAC;AACjB,CAAC;AAED,oBAAoB;AACpB,SAAS,4BAA4B,CAAC,YAAmC;IACxE,MAAM,QAAQ,GAAmB,EAAE,CAAC;IACpC,IAAI,YAAY,CAAC,QAAQ,KAAK,SAAS,EAAE;QACxC,MAAM,IAAI,GAA0B,EAAE,QAAQ,EAAE,YAAY,CAAC,QAAQ,EAAE,CAAC;QACxE,IAAI,YAAY,CAAC,UAAU,KAAK,SAAS,EAAE;YAC1C,IAAI,CAAC,UAAU,GAAG,YAAY,CAAC,UAAU,CAAC;SAC1C;QACD,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;KACpB;IACD,OAAO,QAAQ,CAAC;AACjB,CAAC;AAED,SAAS,iBAAiB,CACzB,aAAqC,EACrC,MAA4B,EAC5B,KAAe;IAEf,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,IAAI,aAAa,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IACrE,IAAI,KAAK,KAAK,IAAI,IAAI,MAAM,CAAC,OAAO,KAAK,SAAS,EAAE;QACnD,MAAM,CAAC,OAAO,GAAG,OAAO,CAAC;KACzB;IAED,OAAO,IAAA,kCAAkB,EAAC,OAAO,EAAE,IAAA,uBAAe,GAAE,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC;AACxE,CAAC;AAmDD,SAAgB,YAAY,CAC3B,UAAmE,EACnE,YAA+B,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,SAAS;IAE5D,IAAI,CAAgB,CAAC;IACrB,IAAI,IAAqB,CAAC;IAC1B,IAAI,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE;QAC9B,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,UAAU,CAAC;KACvB;SAAM;QACN,CAAC,GAAG,UAAU,CAAC;KACf;IACD,KAAK,IAAI,GAAG,GAAG,CAAC,EAAE,GAAG,KAAK,SAAS,EAAE,GAAG,GAAG,GAAG,CAAC,MAAM,EAAE;QACtD,IAAI,SAAS,CAAC,GAAG,CAAC,EAAE;YACnB,IAAI,EAAE,OAAO,EAAE,CAAC;YAChB,OAAO,GAAG,CAAC;SACX;QACD,IAAI,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC;KAChB;IAED,IAAI,IAAI,KAAK,SAAS,EAAE;QACvB,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;KAChB;IACD,OAAO,SAAS,CAAC;AAClB,CAAC;AAvBD,oCAuBC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,SAAgB,kBAAkB,CACjC,WAAyD,EACzD,WAAyD;IAEzD,IAAI,CAAgB,CAAC;IACrB,IAAI,CAAgB,CAAC;IACrB,IAAI,KAAsB,CAAC;IAC3B,IAAI,KAAsB,CAAC;IAC3B,IAAI,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE;QAC/B,CAAC,CAAC,EAAE,KAAK,CAAC,GAAG,WAAW,CAAC;QACzB,IAAA,mBAAM,EAAC,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,KAAK,CAAC,0BAA0B,CAAC,CAAC;KACpF;SAAM;QACN,CAAC,GAAG,WAAW,CAAC;KAChB;IACD,IAAI,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE;QAC/B,CAAC,CAAC,EAAE,KAAK,CAAC,GAAG,WAAW,CAAC;QACzB,IAAA,mBAAM,EAAC,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,KAAK,CAAC,0BAA0B,CAAC,CAAC;KACpF;SAAM;QACN,CAAC,GAAG,WAAW,CAAC;KAChB;IAED,IAAI,CAAC,KAAK,CAAC,EAAE;QACZ,OAAO,CAAC,CAAC;KACT;IAED,MAAM,YAAY,GAAG,GAAG,EAAE;QACzB,KAAK,EAAE,OAAO,EAAE,CAAC;QACjB,KAAK,EAAE,OAAO,EAAE,CAAC;IAClB,CAAC,CAAC;IAEF,MAAM,OAAO,GAAG,IAAI,GAAG,EAAE,CAAC;IAC1B,OAAO,CAAC,KAAK,SAAS,IAAI,CAAC,KAAK,SAAS,EAAE;QAC1C,IAAI,CAAC,KAAK,SAAS,EAAE;YACpB,IAAI,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE;gBACnB,IAAI,KAAK,KAAK,SAAS,EAAE;oBACxB,KAAK,CAAC,MAAM,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;iBACvD;gBACD,YAAY,EAAE,CAAC;gBACf,OAAO,CAAC,CAAC;aACT;YACD,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;YACf,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;YACf,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC;SACb;QAED,IAAI,CAAC,KAAK,SAAS,EAAE;YACpB,IAAI,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE;gBACnB,IAAI,KAAK,KAAK,SAAS,EAAE;oBACxB,KAAK,CAAC,MAAM,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;iBACvD;gBACD,YAAY,EAAE,CAAC;gBACf,OAAO,CAAC,CAAC;aACT;YACD,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;YACf,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;YACf,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC;SACb;KACD;IAED,IAAI,KAAK,KAAK,SAAS,EAAE;QACxB,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;KACjB;IACD,IAAI,KAAK,KAAK,SAAS,EAAE;QACxB,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;KACjB;IACD,OAAO,SAAS,CAAC;AAClB,CAAC;AAlED,gDAkEC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { assert } from \"@fluidframework/core-utils\";\nimport { Mutable } from \"../../util\";\nimport {\n\tChangeRebaser,\n\tRevisionInfo,\n\tRevisionMetadataSource,\n\tTaggedChange,\n\ttagRollbackInverse,\n} from \"./changeRebaser\";\nimport { GraphCommit, mintRevisionTag, mintCommit, RevisionTag } from \"./types\";\n\n/**\n * Contains information about how the commit graph changed as the result of rebasing a source branch onto another target branch.\n * @remarks\n * ```text\n * Consider the commit graph below containing two branches, X and Y, with head commits C and E, respectively.\n * Branch Y branches off of Branch X at their common ancestor commit A, i.e. \"Y is based off of X at commit A\".\n *\n *   A ─ B ─ C ← Branch X\n *   └─ D ─ E ← Branch Y\n *\n * Branch Y is then rebased onto Branch X. This results in the following commit graph:\n *\n *   A ─ B ─ C ← Branch X\n *           └─ D'─ E'← Branch Y\n *\n * Commits D' and E' are the rebased versions of commits D and E, respectively. This results in:\n * deletedSourceCommits: [D, E],\n * targetCommits: [B, C],\n * sourceCommits: [D', E']\n * ```\n */\nexport interface RebasedCommits<TChange> {\n\t/**\n\t * The commits on the original source branch that were rebased. These are no longer referenced by the source branch and have\n\t * been replaced with new versions on the new source branch, see {@link sourceCommits}. In the case that the source\n\t * branch was already ahead of the target branch before the rebase, this list will be empty.\n\t */\n\tdeletedSourceCommits: GraphCommit<TChange>[];\n\t/**\n\t * All commits on the target branch that the source branch's commits were rebased over. These are now the direct\n\t * ancestors of {@link sourceCommits}. In the case that the source branch was already ahead of the target branch\n\t * before the rebase, this list will be empty.\n\t */\n\ttargetCommits: GraphCommit<TChange>[];\n\t/**\n\t * All commits on the source branch that are not also on the target branch after the rebase operation. In the case that the\n\t * source branch was already ahead of the target branch before the rebase, these are the same commits that were already on\n\t * the source branch before the rebase, otherwise these are the new, rebased versions of {@link deletedSourceCommits}.\n\t */\n\tsourceCommits: GraphCommit<TChange>[];\n}\n\nexport interface BranchRebaseResult<TChange> {\n\t/**\n\t * The head of a rebased source branch.\n\t */\n\treadonly newSourceHead: GraphCommit<TChange>;\n\t/**\n\t * A thunk that computes the cumulative change to the source branch (undefined if no change occurred)\n\t */\n\treadonly sourceChange: TChange | undefined;\n\t/**\n\t * Details about how the commits on the source branch changed\n\t */\n\treadonly commits: RebasedCommits<TChange>;\n}\n\n/**\n * Rebases a source branch onto another commit in a target branch.\n *\n * A \"branch\" is defined as a \"head\" commit and all ancestors of that commit, i.e. one linked list in a graph of commits.\n *\n * The source and target branch must share an ancestor.\n * @param changeRebaser - the change rebaser responsible for rebasing the changes in the commits of each branch\n * @param sourceHead - the head of the source branch, which will be rebased onto `targetHead`\n * @param targetHead - the commit to rebase the source branch onto\n * @returns a {@link BranchRebaseResult}\n * @remarks While a single branch must not have multiple commits with the same revision tag (that will result in undefined\n * behavior), there may be a commit on the source branch with the same revision tag as a commit on the target branch. If such\n * a pair is encountered while rebasing, it will be \"cancelled out\" in the new branch. For example:\n * ```\n * // (A)-(B)-(C) <- Branch X\n * //   \\\n * //   (B')-(D) <- Branch Y\n * //\n * // As Branch Y is rebased onto Branch X, commits B and B' cancel out so there is no version of B on the new rebased source branch\n * //\n * // (A)-(B)-(C) <- Branch X\n * //           \\\n * //           (D') <- Branch Y'\n * //\n * ```\n */\nexport function rebaseBranch<TChange>(\n\tchangeRebaser: ChangeRebaser<TChange>,\n\tsourceHead: GraphCommit<TChange>,\n\ttargetHead: GraphCommit<TChange>,\n): BranchRebaseResult<TChange>;\n\n/**\n * Rebases a source branch onto another commit in a target branch.\n *\n * A \"branch\" is defined as a \"head\" commit and all ancestors of that commit, i.e. one linked list in a graph of commits.\n *\n * The source and target branch must share an ancestor.\n * @param changeRebaser - the change rebaser responsible for rebasing the changes in the commits of each branch\n * @param sourceHead - the head of the source branch, which will be rebased onto `newBase`\n * @param targetCommit - the commit on the target branch to rebase the source branch onto.\n * @param targetHead - the head of the branch that `newBase` belongs to. Must be `newBase` or a descendent of `newBase`.\n * @returns a {@link BranchRebaseResult}\n * @remarks While a single branch must not have multiple commits with the same revision tag (that will result in undefined\n * behavior), there may be a commit on the source branch with the same revision tag as a commit on the target branch. If such\n * a pair is encountered while rebasing, it will be \"cancelled out\" in the new branch. Additionally, this function will rebase\n * the source branch _farther_ than `newBase` if the source branch's next commits after `newBase` match those on the target branch.\n * For example:\n * ```\n * // (A)-(B)-(C)-(D)-(E) <- Branch X\n * //   \\\n * //   (B')-(D')-(F) <- Branch Y\n * //\n * // If Branch Y is rebased onto commit C of Branch X, the branches must at least look like this afterwards (B was cancelled out):\n * //\n * // (A)-(B)-(C)-(D)-(E) <- Branch X\n * //           \\\n * //           (D'')-(F') <- Branch Y'\n * //\n * // But this function will recognize that B is equivalent to B' and D is equivalent to D', and instead produce:\n * //\n * // (A)-(B)-(C)-(D)-(E) <- Branch X\n * //               \\\n * //               (F') <- Branch Y'\n * ```\n */\nexport function rebaseBranch<TChange>(\n\tchangeRebaser: ChangeRebaser<TChange>,\n\tsourceHead: GraphCommit<TChange>,\n\ttargetCommit: GraphCommit<TChange>,\n\ttargetHead: GraphCommit<TChange>,\n): BranchRebaseResult<TChange>;\nexport function rebaseBranch<TChange>(\n\tchangeRebaser: ChangeRebaser<TChange>,\n\tsourceHead: GraphCommit<TChange>,\n\ttargetCommit: GraphCommit<TChange>,\n\ttargetHead = targetCommit,\n): BranchRebaseResult<TChange> {\n\t// Get both source and target as path arrays\n\tconst sourcePath: GraphCommit<TChange>[] = [];\n\tconst targetPath: GraphCommit<TChange>[] = [];\n\tconst ancestor = findCommonAncestor([sourceHead, sourcePath], [targetHead, targetPath]);\n\tassert(ancestor !== undefined, 0x675 /* branches must be related */);\n\n\t// Find where `targetCommit` is in the target branch\n\tconst targetCommitIndex = targetPath.findIndex((r) => r === targetCommit);\n\tif (targetCommitIndex === -1) {\n\t\t// If the targetCommit is not in the target path, then it is either disjoint from `target` or it is behind/at\n\t\t// the commit where source and target diverge (ancestor), in which case there is nothing more to rebase\n\t\t// TODO: Ideally, this would be an \"assertExpensive\"\n\t\tassert(\n\t\t\tfindCommonAncestor(targetCommit, targetHead) !== undefined,\n\t\t\t0x676 /* target commit is not in target branch */,\n\t\t);\n\t\treturn {\n\t\t\tnewSourceHead: sourceHead,\n\t\t\tsourceChange: undefined,\n\t\t\tcommits: { deletedSourceCommits: [], targetCommits: [], sourceCommits: sourcePath },\n\t\t};\n\t}\n\n\t// Iterate through the target path and look for commits that are also present on the source branch (i.e. they\n\t// have matching tags). Each commit found in the target branch can be skipped when processing the source branch\n\t// because it has already been rebased onto the target. In the case that one or more of these commits are present\n\t// directly after `targetCommit`, then the new base can be advanced further without having to do any work.\n\tconst sourceSet = new Set(sourcePath.map((r) => r.revision));\n\tlet newBaseIndex = targetCommitIndex;\n\n\tfor (let i = 0; i < targetPath.length; i += 1) {\n\t\tconst { revision } = targetPath[i];\n\t\tif (sourceSet.has(revision)) {\n\t\t\tsourceSet.delete(revision);\n\t\t\tnewBaseIndex = Math.max(newBaseIndex, i);\n\t\t} else if (i > targetCommitIndex) {\n\t\t\tbreak;\n\t\t}\n\t}\n\n\t/** The commit on the target branch that the new source branch branches off of (i.e. the new common ancestor) */\n\tconst newBase = targetPath[newBaseIndex];\n\t// Figure out how much of the trunk to start rebasing over.\n\tconst targetCommits = targetPath.slice(0, newBaseIndex + 1);\n\tconst deletedSourceCommits = [...sourcePath];\n\n\t// If the source and target rebase path begin with a range that has all the same revisions, remove it; it is\n\t// equivalent on both branches and doesn't need to be rebased.\n\tconst targetRebasePath = [...targetCommits];\n\tconst minLength = Math.min(sourcePath.length, targetRebasePath.length);\n\tfor (let i = 0; i < minLength; i++) {\n\t\tif (sourcePath[0].revision === targetRebasePath[0].revision) {\n\t\t\tsourcePath.shift();\n\t\t\ttargetRebasePath.shift();\n\t\t}\n\t}\n\n\tconst sourceCommits: GraphCommit<TChange>[] = [];\n\n\t// If all commits that are about to be rebased over on the target branch already comprise the start of the source branch,\n\t// are in the same order, and have no other commits interleaving them, then no rebasing needs to occur. Those commits can\n\t// simply be removed from the source branch, and the remaining commits on the source branch are reparented off of the new\n\t// base commit.\n\tif (targetRebasePath.length === 0) {\n\t\tfor (const c of sourcePath) {\n\t\t\tsourceCommits.push(mintCommit(sourceCommits[sourceCommits.length - 1] ?? newBase, c));\n\t\t}\n\t\treturn {\n\t\t\tnewSourceHead: sourceCommits[sourceCommits.length - 1] ?? newBase,\n\t\t\tsourceChange: undefined,\n\t\t\tcommits: {\n\t\t\t\tdeletedSourceCommits,\n\t\t\t\ttargetCommits,\n\t\t\t\tsourceCommits,\n\t\t\t},\n\t\t};\n\t}\n\n\t// For each source commit, rebase backwards over the inverses of any commits already rebased, and then\n\t// rebase forwards over the rest of the commits up to the new base before advancing the new base.\n\tlet newHead = newBase;\n\tconst inverses: TaggedChange<TChange>[] = [];\n\tfor (const c of sourcePath) {\n\t\tif (sourceSet.has(c.revision)) {\n\t\t\tconst change = rebaseChangeOverChanges(changeRebaser, c.change, [\n\t\t\t\t...inverses,\n\t\t\t\t...targetRebasePath,\n\t\t\t]);\n\t\t\tnewHead = {\n\t\t\t\trevision: c.revision,\n\t\t\t\tchange,\n\t\t\t\tparent: newHead,\n\t\t\t};\n\t\t\tsourceCommits.push(newHead);\n\t\t\ttargetRebasePath.push({ ...c, change });\n\t\t}\n\t\tinverses.unshift(\n\t\t\ttagRollbackInverse(changeRebaser.invert(c, true), mintRevisionTag(), c.revision),\n\t\t);\n\t}\n\n\tlet netChange: TChange | undefined;\n\treturn {\n\t\tnewSourceHead: newHead,\n\t\tget sourceChange() {\n\t\t\tif (netChange === undefined) {\n\t\t\t\tnetChange = changeRebaser.compose([...inverses, ...targetRebasePath]);\n\t\t\t}\n\t\t\treturn netChange;\n\t\t},\n\t\tcommits: {\n\t\t\tdeletedSourceCommits,\n\t\t\ttargetCommits,\n\t\t\tsourceCommits,\n\t\t},\n\t};\n}\n\n/**\n * \"Sandwich/Horseshoe Rebase\" a change over the given source and target branches\n * @param changeRebaser - the change rebaser responsible for rebasing the change over the commits in each branch\n * @param change - the change to rebase\n * @param sourceHead - the head of the branch that `change` is based on\n * @param targetHead - the branch to rebase `change` onto\n * @returns the rebased change\n *\n * @remarks inverses will be cached.\n */\nexport function rebaseChange<TChange>(\n\tchangeRebaser: ChangeRebaser<TChange>,\n\tchange: TChange,\n\tsourceHead: GraphCommit<TChange>,\n\ttargetHead: GraphCommit<TChange>,\n): TChange {\n\tconst sourcePath: GraphCommit<TChange>[] = [];\n\tconst targetPath: GraphCommit<TChange>[] = [];\n\tassert(\n\t\tfindCommonAncestor([sourceHead, sourcePath], [targetHead, targetPath]) !== undefined,\n\t\t0x576 /* branch A and branch B must be related */,\n\t);\n\n\tconst inverses = sourcePath.map((commit) => inverseFromCommit(changeRebaser, commit, true));\n\tinverses.reverse();\n\treturn rebaseChangeOverChanges(changeRebaser, change, [...inverses, ...targetPath]);\n}\n\n/**\n * @internal\n */\nexport function revisionMetadataSourceFromInfo(\n\trevInfos: readonly RevisionInfo[],\n): RevisionMetadataSource {\n\tconst getIndex = (revision: RevisionTag): number | undefined => {\n\t\tconst index = revInfos.findIndex((revInfo) => revInfo.revision === revision);\n\t\treturn index >= 0 ? index : undefined;\n\t};\n\tconst tryGetInfo = (revision: RevisionTag | undefined): RevisionInfo | undefined => {\n\t\tif (revision === undefined) {\n\t\t\treturn undefined;\n\t\t}\n\t\tconst index = getIndex(revision);\n\t\treturn index === undefined ? undefined : revInfos[index];\n\t};\n\n\tconst hasRollback = (revision: RevisionTag): boolean => {\n\t\treturn revInfos.find((info) => info.rollbackOf === revision) !== undefined;\n\t};\n\n\treturn { getIndex, tryGetInfo, hasRollback };\n}\n\nexport function rebaseChangeOverChanges<TChange>(\n\tchangeRebaser: ChangeRebaser<TChange>,\n\tchangeToRebase: TChange,\n\tchangesToRebaseOver: TaggedChange<TChange>[],\n) {\n\tconst revisionMetadata = revisionMetadataSourceFromInfo(\n\t\tgetRevInfoFromTaggedChanges(changesToRebaseOver),\n\t);\n\n\treturn changesToRebaseOver.reduce(\n\t\t(a, b) => changeRebaser.rebase(a, b, revisionMetadata),\n\t\tchangeToRebase,\n\t);\n}\n\n// TODO: Deduplicate\nfunction getRevInfoFromTaggedChanges(changes: TaggedChange<unknown>[]): RevisionInfo[] {\n\tconst revInfos: RevisionInfo[] = [];\n\tfor (const taggedChange of changes) {\n\t\trevInfos.push(...revisionInfoFromTaggedChange(taggedChange));\n\t}\n\n\treturn revInfos;\n}\n\n// TODO: Deduplicate\nfunction revisionInfoFromTaggedChange(taggedChange: TaggedChange<unknown>): RevisionInfo[] {\n\tconst revInfos: RevisionInfo[] = [];\n\tif (taggedChange.revision !== undefined) {\n\t\tconst info: Mutable<RevisionInfo> = { revision: taggedChange.revision };\n\t\tif (taggedChange.rollbackOf !== undefined) {\n\t\t\tinfo.rollbackOf = taggedChange.rollbackOf;\n\t\t}\n\t\trevInfos.push(info);\n\t}\n\treturn revInfos;\n}\n\nfunction inverseFromCommit<TChange>(\n\tchangeRebaser: ChangeRebaser<TChange>,\n\tcommit: GraphCommit<TChange>,\n\tcache?: boolean,\n): TaggedChange<TChange> {\n\tconst inverse = commit.inverse ?? changeRebaser.invert(commit, true);\n\tif (cache === true && commit.inverse === undefined) {\n\t\tcommit.inverse = inverse;\n\t}\n\n\treturn tagRollbackInverse(inverse, mintRevisionTag(), commit.revision);\n}\n\n/**\n * Find the furthest ancestor of some descendant.\n * @param descendant - a descendant. If an empty `path` array is included, it will be populated\n * with the chain of ancestry for `descendant` from most distant to closest (not including the furthest ancestor,\n * but otherwise including `descendant`).\n * @returns the furthest ancestor of `descendant`, or `descendant` itself if `descendant` has no ancestors.\n */\nexport function findAncestor<T extends { parent?: T }>(\n\tdescendant: T | [descendant: T, path?: T[]],\n): T;\n/**\n * Find the furthest ancestor of some descendant.\n * @param descendant - a descendant. If an empty `path` array is included, it will be populated\n * with the chain of ancestry for `descendant` from most distant to closest (not including the furthest ancestor,\n * but otherwise including `descendant`).\n * @returns the furthest ancestor of `descendant`, or `descendant` itself if `descendant` has no ancestors. Returns\n * `undefined` if `descendant` is undefined.\n */\nexport function findAncestor<T extends { parent?: T }>(\n\tdescendant: T | [descendant: T | undefined, path?: T[]] | undefined,\n): T | undefined;\n/**\n * Find an ancestor of some descendant.\n * @param descendant - a descendant. If an empty `path` array is included, it will be populated\n * with the chain of ancestry for `descendant` from most distant to closest (not including the ancestor found by `predicate`,\n * but otherwise including `descendant`).\n * @param predicate - a function which will be evaluated on every ancestor of `descendant` until it returns true.\n * @returns the closest ancestor of `descendant` that satisfies `predicate`, or `undefined` if no such ancestor exists.\n *\n * @example\n *\n * ```typescript\n * interface Parented {\n *   id: string;\n *   parent?: Parented;\n * }\n * const g = { id: \"g\" }; // Grandparent\n * const p = { parent: g, id: \"p\" }; // Parent\n * const c = { parent: p, id: \"c\" }; // Child\n * const path: Parented[] = [];\n * const ancestor = findAncestor<Parented>([c, path], (n) => n.id === \"g\");\n * // ancestor === g\n * // path === [p, c]\n * ```\n */\nexport function findAncestor<T extends { parent?: T }>(\n\tdescendant: T | [descendant: T | undefined, path?: T[]] | undefined,\n\tpredicate: (t: T) => boolean,\n): T | undefined;\nexport function findAncestor<T extends { parent?: T }>(\n\tdescendant: T | [descendant: T | undefined, path?: T[]] | undefined,\n\tpredicate: (t: T) => boolean = (t) => t.parent === undefined,\n): T | undefined {\n\tlet d: T | undefined;\n\tlet path: T[] | undefined;\n\tif (Array.isArray(descendant)) {\n\t\t[d, path] = descendant;\n\t} else {\n\t\td = descendant;\n\t}\n\tfor (let cur = d; cur !== undefined; cur = cur.parent) {\n\t\tif (predicate(cur)) {\n\t\t\tpath?.reverse();\n\t\t\treturn cur;\n\t\t}\n\t\tpath?.push(cur);\n\t}\n\n\tif (path !== undefined) {\n\t\tpath.length = 0;\n\t}\n\treturn undefined;\n}\n\n/**\n * Find a common ancestor between two descendants that are linked by parent pointers.\n * @param descendantA - a descendant. If an empty `path` array is included, it will be populated\n * with the chain of commits from the ancestor to `descendantA` (not including the ancestor).\n * @param descendantB - another descendant. If an empty `path` array is included, it will be populated\n * with the chain of commits from the ancestor to `descendantB` (not including the ancestor).\n * @returns the common ancestor of `descendantA` and `descendantB`, or `undefined` if no such ancestor exists.\n *\n * @example\n *\n * ```typescript\n * interface Parented {\n *   parent?: Parented;\n * }\n * const shared = {};\n * const a = { parent: shared };\n * const b1 = { parent: shared };\n * const b2 = { parent: b1 };\n * const pathB: Parented[] = []\n * const ancestor = findCommonAncestor<Parented>(a, [b2, pathB]);\n * // ancestor === shared\n * // pathB === [b1, b2]\n * ```\n */\nexport function findCommonAncestor<T extends { parent?: T }>(\n\tdescendantA: T | [descendantA: T, path?: T[]] | undefined,\n\tdescendantB: T | [descendantB: T, path?: T[]] | undefined,\n): T | undefined {\n\tlet a: T | undefined;\n\tlet b: T | undefined;\n\tlet pathA: T[] | undefined;\n\tlet pathB: T[] | undefined;\n\tif (Array.isArray(descendantA)) {\n\t\t[a, pathA] = descendantA;\n\t\tassert(pathA === undefined || pathA.length === 0, 0x578 /* Path A must be empty */);\n\t} else {\n\t\ta = descendantA;\n\t}\n\tif (Array.isArray(descendantB)) {\n\t\t[b, pathB] = descendantB;\n\t\tassert(pathB === undefined || pathB.length === 0, 0x579 /* Path B must be empty */);\n\t} else {\n\t\tb = descendantB;\n\t}\n\n\tif (a === b) {\n\t\treturn a;\n\t}\n\n\tconst reversePaths = () => {\n\t\tpathA?.reverse();\n\t\tpathB?.reverse();\n\t};\n\n\tconst visited = new Set();\n\twhile (a !== undefined || b !== undefined) {\n\t\tif (a !== undefined) {\n\t\t\tif (visited.has(a)) {\n\t\t\t\tif (pathB !== undefined) {\n\t\t\t\t\tpathB.length = pathB.findIndex((r) => Object.is(r, a));\n\t\t\t\t}\n\t\t\t\treversePaths();\n\t\t\t\treturn a;\n\t\t\t}\n\t\t\tvisited.add(a);\n\t\t\tpathA?.push(a);\n\t\t\ta = a.parent;\n\t\t}\n\n\t\tif (b !== undefined) {\n\t\t\tif (visited.has(b)) {\n\t\t\t\tif (pathA !== undefined) {\n\t\t\t\t\tpathA.length = pathA.findIndex((r) => Object.is(r, b));\n\t\t\t\t}\n\t\t\t\treversePaths();\n\t\t\t\treturn b;\n\t\t\t}\n\t\t\tvisited.add(b);\n\t\t\tpathB?.push(b);\n\t\t\tb = b.parent;\n\t\t}\n\t}\n\n\tif (pathA !== undefined) {\n\t\tpathA.length = 0;\n\t}\n\tif (pathB !== undefined) {\n\t\tpathB.length = 0;\n\t}\n\treturn undefined;\n}\n"]}

package/dist/core/rebase/verifyChangeRebaser.d.ts

@@ -0,0 +1,76 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { ChangeRebaser } from "./changeRebaser";
+export type Failure<TCase> = Violation<TCase> | Exception<TCase>;
+export interface Violation<TCase> {
+    type: "Violation";
+    case: TCase;
+}
+export interface Exception<TCase> {
+    type: "Error";
+    case: TCase;
+    error: unknown;
+}
+export interface OutputType<TChange> {
+    /**
+     * "Passed" iff `(A ○ B) ○ C = A (B ○ C) = A ○ B ○ C`,
+     * otherwise a triple that violates the axiom.
+     */
+    composeAssociativity: Failure<[TChange, TChange, TChange]>[];
+    /**
+     * "Passed" iff `A ↷ (B ○ C) = (A ↷ B) ↷ C`,
+     * otherwise a triple that violates the axiom.
+     */
+    rebaseLeftDistributivity: Failure<[TChange, TChange, TChange]>[];
+    /**
+     * "Passed" iff `(A ○ B) ↷ C = (A ↷ C) ○ (B ↷ (A⁻¹ ○ C ○ (A ↷ C)) ↷ C)`,
+     * otherwise a triple that violates the axiom.
+     */
+    rebaseRightDistributivity: Failure<[TChange, TChange, TChange]>[];
+    /**
+     * "Passed" iff `(A ↷ B) ↷ B⁻¹ = A`,
+     * otherwise a pair that violates the axiom.
+     */
+    rebaseOverDoUndoPairIsNoOp: Failure<[TChange, TChange]>[];
+    /**
+     * "Passed" iff `((A ↷ B) ↷ B⁻¹) ↷ B = A ↷ B`,
+     * otherwise a pair that violates the axiom.
+     */
+    rebaseOverUndoRedoPairIsNoOp: Failure<[TChange, TChange]>[];
+    /**
+     * "Passed" iff `A ○ A⁻¹ = ε` where `ε` is the empty change,
+     * otherwise a change that violates the axiom.
+     */
+    composeWithInverseIsNoOp: Failure<TChange>[];
+    /**
+     * "Passed" iff `A ○ ε` is equal to `ε ○ A` which equals to `A` where `ε` is the empty change,
+     * otherwise a change that violates the axiom.
+     */
+    composeWithEmptyIsNoOp: Failure<TChange>[];
+    /**
+     * "Passed" iff `(A ↷ ε) = A`,
+     * otherwise a change that violates the axiom.
+     */
+    rebaseOverEmptyIsNoOp: Failure<TChange>[];
+    /**
+     * "Passed" iff `(ε ↷ A) = ε`,
+     * otherwise a change that violates the axiom.
+     */
+    rebaseEmptyIsEmpty: Failure<TChange>[];
+    /**
+     * "Passed" iff `ε⁻¹ = ε`,
+     * otherwise a change that violates the axiom.
+     */
+    emptyInverseIsEmpty: Failure<TChange>[];
+}
+export declare const noFailure: OutputType<unknown>;
+/**
+ * Verifies the axioms of `ChangeRebaser` are met by the given `rebaser`.
+ * @param rebaser - The rebaser to test.
+ * @param changes - The set of changes to use for testing the `rebaser`.
+ * @param isEquivalent - Used to compare whether two changes are equivalent for the purposes of this axioms.
+ */
+export declare function verifyChangeRebaser<TChange>(rebaser: ChangeRebaser<TChange>, changes: ReadonlySet<TChange>, isEquivalent: (a: TChange, b: TChange) => boolean): OutputType<TChange>;
+//# sourceMappingURL=verifyChangeRebaser.d.ts.map