@fluidframework/tree 2.0.0-dev-rc.1.0.0.224419

package/lib/core/rebase/changeRebaser.d.ts

@@ -0,0 +1,132 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { Invariant } from "../../util";
+import type { RevisionTag } from "./types";
+/**
+ * Rebasing logic for a particular kind of change.
+ *
+ * This interface is used to provide rebase policy to `Rebaser`.
+ *
+ * The implementation must ensure TChangeset forms a [group](https://en.wikipedia.org/wiki/Group_(mathematics)) where:
+ * - `compose([])` is the identity element.
+ * - associativity is defined as `compose([...a, ...b])` is equal to
+ * `compose([compose(a), compose(b)])` for all `a` and `b`.
+ * - `inverse(a)` gives the inverse element of `a`.
+ *
+ * In these requirements the definition of equality is up to the implementer,
+ * but it is required that any two changes which are considered equal:
+ * - have the same impact when applied to any tree.
+ * - can be substituted for each-other in all methods on this
+ * interface and produce equal (by this same definition) results.
+ *
+ * For the sake of testability, implementations will likely want to have a concrete equality implementation.
+ *
+ * This API uses `compose` on arrays instead of an explicit identity element and associative binary operator
+ * to allow the implementation more room for optimization,
+ * but should otherwise be equivalent to the identity element and binary operator group approach.
+ *
+ * TODO:
+ * Be more specific about the above requirements.
+ * For example, would something that is close to forming a group but has precision issues
+ * (ex: the floating point numbers and addition) be ok?
+ * Would this cause decoherence (and thus be absolutely not ok),
+ * or just minor semantic precision issues, which could be tolerated.
+ * For now assume that such issues are not ok.
+ */
+export interface ChangeRebaser<TChangeset> {
+    _typeCheck?: Invariant<TChangeset>;
+    /**
+     * Compose a collection of changesets into a single one.
+     * See {@link ChangeRebaser} for requirements.
+     */
+    compose(changes: TaggedChange<TChangeset>[]): TChangeset;
+    /**
+     * @param changes - The changes to invert.
+     * @param isRollback - Whether the inverted change is meant to rollback a change on a branch as is the case when
+     * performing a sandwich rebase.
+     * This flag is relevant to merge semantics that are dependent on edit sequencing order:
+     * - In the context of an undo, this function inverts a change that is sequenced and applied before the produced inverse.
+     * - In the context of a rollback, this function inverts a change that is sequenced after but applied before the produced inverse.
+     * @returns the inverse of `changes`.
+     *
+     * `compose([changes, inverse(changes)])` be equal to `compose([])`:
+     * See {@link ChangeRebaser} for details.
+     */
+    invert(changes: TaggedChange<TChangeset>, isRollback: boolean): TChangeset;
+    /**
+     * Rebase `change` over `over`.
+     *
+     * The resulting changeset should, as much as possible, replicate the same semantics as `change`,
+     * except be valid to apply after `over` instead of before it.
+     *
+     * When rebasing `change` onto a new branch, `revisionMetadata` should include entries for all changesets
+     * from the source which are being rebased onto the target branch.
+     *
+     * Requirements:
+     * The implementation must ensure that for all possible changesets `a`, `b` and `c`:
+     * - `rebase(a, compose([b, c])` is equal to `rebase(rebase(a, b), c)`.
+     * - `rebase(compose([a, b]), c)` is equal to
+     * `compose([rebase(a, c), rebase(b, compose([inverse(a), c, rebase(a, c)])])`.
+     * - `rebase(a, compose([]))` is equal to `a`.
+     * - `rebase(compose([]), a)` is equal to `compose([])`.
+     */
+    rebase(change: TChangeset, over: TaggedChange<TChangeset>, revisionMetadata: RevisionMetadataSource): TChangeset;
+}
+/**
+ * @internal
+ */
+export interface TaggedChange<TChangeset> {
+    readonly revision: RevisionTag | undefined;
+    /**
+     * When populated, indicates that the changeset is a rollback for the purpose of a rebase sandwich.
+     * The value corresponds to the `revision` of the original changeset being rolled back.
+     */
+    readonly rollbackOf?: RevisionTag;
+    readonly change: TChangeset;
+}
+export declare function mapTaggedChange<TIn, TOut>(input: TaggedChange<TIn>, change: TOut): TaggedChange<TOut>;
+/**
+ * A callback that returns the index of the changeset associated with the given RevisionTag among the changesets being
+ * composed or rebased. This index is solely meant to communicate relative ordering, and is only valid within the scope of the
+ * compose or rebase operation.
+ *
+ * During composition, the index reflects the order of the changeset within the overall composed changeset that is
+ * being produced.
+ *
+ * During rebase, the indices of the base changes are all lower than the indices of the change being rebased.
+ * @internal
+ */
+export type RevisionIndexer = (tag: RevisionTag) => number | undefined;
+/**
+ * @internal
+ */
+export interface RevisionMetadataSource {
+    readonly getIndex: RevisionIndexer;
+    readonly tryGetInfo: (tag: RevisionTag | undefined) => RevisionInfo | undefined;
+    readonly hasRollback: (tag: RevisionTag) => boolean;
+}
+/**
+ * @internal
+ */
+export interface RevisionInfo {
+    readonly revision: RevisionTag;
+    /**
+     * When populated, indicates that the changeset is a rollback for the purpose of a rebase sandwich.
+     * The value corresponds to the `revision` of the original changeset being rolled back.
+     */
+    readonly rollbackOf?: RevisionTag;
+}
+export declare function tagChange<T>(change: T, revision: RevisionTag | undefined): TaggedChange<T>;
+export declare function tagRollbackInverse<T>(inverseChange: T, revision: RevisionTag | undefined, rollbackOf: RevisionTag | undefined): TaggedChange<T>;
+export declare function makeAnonChange<T>(change: T): TaggedChange<T>;
+export interface FinalChange {
+    readonly status: FinalChangeStatus;
+}
+export declare enum FinalChangeStatus {
+    conflicted = 0,
+    rebased = 1,
+    commuted = 2
+}
+//# sourceMappingURL=changeRebaser.d.ts.map

package/lib/core/rebase/changeRebaser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"changeRebaser.d.ts","sourceRoot":"","sources":["../../../src/core/rebase/changeRebaser.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,WAAW,aAAa,CAAC,UAAU;IACxC,UAAU,CAAC,EAAE,SAAS,CAAC,UAAU,CAAC,CAAC;IAEnC;;;OAGG;IACH,OAAO,CAAC,OAAO,EAAE,YAAY,CAAC,UAAU,CAAC,EAAE,GAAG,UAAU,CAAC;IAEzD;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,OAAO,EAAE,YAAY,CAAC,UAAU,CAAC,EAAE,UAAU,EAAE,OAAO,GAAG,UAAU,CAAC;IAE3E;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,CACL,MAAM,EAAE,UAAU,EAClB,IAAI,EAAE,YAAY,CAAC,UAAU,CAAC,EAC9B,gBAAgB,EAAE,sBAAsB,GACtC,UAAU,CAAC;CACd;AAED;;GAEG;AACH,MAAM,WAAW,YAAY,CAAC,UAAU;IACvC,QAAQ,CAAC,QAAQ,EAAE,WAAW,GAAG,SAAS,CAAC;IAC3C;;;OAGG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,WAAW,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;CAC5B;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,IAAI,EACxC,KAAK,EAAE,YAAY,CAAC,GAAG,CAAC,EACxB,MAAM,EAAE,IAAI,GACV,YAAY,CAAC,IAAI,CAAC,CAEpB;AAED;;;;;;;;;;GAUG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,GAAG,EAAE,WAAW,KAAK,MAAM,GAAG,SAAS,CAAC;AAEvE;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACtC,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAC;IACnC,QAAQ,CAAC,UAAU,EAAE,CAAC,GAAG,EAAE,WAAW,GAAG,SAAS,KAAK,YAAY,GAAG,SAAS,CAAC;IAChF,QAAQ,CAAC,WAAW,EAAE,CAAC,GAAG,EAAE,WAAW,KAAK,OAAO,CAAC;CACpD;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC5B,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC;IAC/B;;;OAGG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,WAAW,CAAC;CAClC;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,QAAQ,EAAE,WAAW,GAAG,SAAS,GAAG,YAAY,CAAC,CAAC,CAAC,CAE1F;AAED,wBAAgB,kBAAkB,CAAC,CAAC,EACnC,aAAa,EAAE,CAAC,EAChB,QAAQ,EAAE,WAAW,GAAG,SAAS,EACjC,UAAU,EAAE,WAAW,GAAG,SAAS,GACjC,YAAY,CAAC,CAAC,CAAC,CAMjB;AAED,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAE5D;AAED,MAAM,WAAW,WAAW;IAC3B,QAAQ,CAAC,MAAM,EAAE,iBAAiB,CAAC;CACnC;AAED,oBAAY,iBAAiB;IAC5B,UAAU,IAAA;IACV,OAAO,IAAA;IACP,QAAQ,IAAA;CACR"}

package/lib/core/rebase/changeRebaser.js

@@ -0,0 +1,27 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+export function mapTaggedChange(input, change) {
+    return { ...input, change };
+}
+export function tagChange(change, revision) {
+    return { revision, change };
+}
+export function tagRollbackInverse(inverseChange, revision, rollbackOf) {
+    return {
+        revision,
+        change: inverseChange,
+        rollbackOf,
+    };
+}
+export function makeAnonChange(change) {
+    return { revision: undefined, change };
+}
+export var FinalChangeStatus;
+(function (FinalChangeStatus) {
+    FinalChangeStatus[FinalChangeStatus["conflicted"] = 0] = "conflicted";
+    FinalChangeStatus[FinalChangeStatus["rebased"] = 1] = "rebased";
+    FinalChangeStatus[FinalChangeStatus["commuted"] = 2] = "commuted";
+})(FinalChangeStatus || (FinalChangeStatus = {}));
+//# sourceMappingURL=changeRebaser.js.map

package/lib/core/rebase/changeRebaser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"changeRebaser.js","sourceRoot":"","sources":["../../../src/core/rebase/changeRebaser.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAgGH,MAAM,UAAU,eAAe,CAC9B,KAAwB,EACxB,MAAY;IAEZ,OAAO,EAAE,GAAG,KAAK,EAAE,MAAM,EAAE,CAAC;AAC7B,CAAC;AAoCD,MAAM,UAAU,SAAS,CAAI,MAAS,EAAE,QAAiC;IACxE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;AAC7B,CAAC;AAED,MAAM,UAAU,kBAAkB,CACjC,aAAgB,EAChB,QAAiC,EACjC,UAAmC;IAEnC,OAAO;QACN,QAAQ;QACR,MAAM,EAAE,aAAa;QACrB,UAAU;KACV,CAAC;AACH,CAAC;AAED,MAAM,UAAU,cAAc,CAAI,MAAS;IAC1C,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,CAAC;AACxC,CAAC;AAMD,MAAM,CAAN,IAAY,iBAIX;AAJD,WAAY,iBAAiB;IAC5B,qEAAU,CAAA;IACV,+DAAO,CAAA;IACP,iEAAQ,CAAA;AACT,CAAC,EAJW,iBAAiB,KAAjB,iBAAiB,QAI5B","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { Invariant } from \"../../util\";\nimport type { RevisionTag } from \"./types\";\n\n/**\n * Rebasing logic for a particular kind of change.\n *\n * This interface is used to provide rebase policy to `Rebaser`.\n *\n * The implementation must ensure TChangeset forms a [group](https://en.wikipedia.org/wiki/Group_(mathematics)) where:\n * - `compose([])` is the identity element.\n * - associativity is defined as `compose([...a, ...b])` is equal to\n * `compose([compose(a), compose(b)])` for all `a` and `b`.\n * - `inverse(a)` gives the inverse element of `a`.\n *\n * In these requirements the definition of equality is up to the implementer,\n * but it is required that any two changes which are considered equal:\n * - have the same impact when applied to any tree.\n * - can be substituted for each-other in all methods on this\n * interface and produce equal (by this same definition) results.\n *\n * For the sake of testability, implementations will likely want to have a concrete equality implementation.\n *\n * This API uses `compose` on arrays instead of an explicit identity element and associative binary operator\n * to allow the implementation more room for optimization,\n * but should otherwise be equivalent to the identity element and binary operator group approach.\n *\n * TODO:\n * Be more specific about the above requirements.\n * For example, would something that is close to forming a group but has precision issues\n * (ex: the floating point numbers and addition) be ok?\n * Would this cause decoherence (and thus be absolutely not ok),\n * or just minor semantic precision issues, which could be tolerated.\n * For now assume that such issues are not ok.\n */\nexport interface ChangeRebaser<TChangeset> {\n\t_typeCheck?: Invariant<TChangeset>;\n\n\t/**\n\t * Compose a collection of changesets into a single one.\n\t * See {@link ChangeRebaser} for requirements.\n\t */\n\tcompose(changes: TaggedChange<TChangeset>[]): TChangeset;\n\n\t/**\n\t * @param changes - The changes to invert.\n\t * @param isRollback - Whether the inverted change is meant to rollback a change on a branch as is the case when\n\t * performing a sandwich rebase.\n\t * This flag is relevant to merge semantics that are dependent on edit sequencing order:\n\t * - In the context of an undo, this function inverts a change that is sequenced and applied before the produced inverse.\n\t * - In the context of a rollback, this function inverts a change that is sequenced after but applied before the produced inverse.\n\t * @returns the inverse of `changes`.\n\t *\n\t * `compose([changes, inverse(changes)])` be equal to `compose([])`:\n\t * See {@link ChangeRebaser} for details.\n\t */\n\tinvert(changes: TaggedChange<TChangeset>, isRollback: boolean): TChangeset;\n\n\t/**\n\t * Rebase `change` over `over`.\n\t *\n\t * The resulting changeset should, as much as possible, replicate the same semantics as `change`,\n\t * except be valid to apply after `over` instead of before it.\n\t *\n\t * When rebasing `change` onto a new branch, `revisionMetadata` should include entries for all changesets\n\t * from the source which are being rebased onto the target branch.\n\t *\n\t * Requirements:\n\t * The implementation must ensure that for all possible changesets `a`, `b` and `c`:\n\t * - `rebase(a, compose([b, c])` is equal to `rebase(rebase(a, b), c)`.\n\t * - `rebase(compose([a, b]), c)` is equal to\n\t * `compose([rebase(a, c), rebase(b, compose([inverse(a), c, rebase(a, c)])])`.\n\t * - `rebase(a, compose([]))` is equal to `a`.\n\t * - `rebase(compose([]), a)` is equal to `compose([])`.\n\t */\n\trebase(\n\t\tchange: TChangeset,\n\t\tover: TaggedChange<TChangeset>,\n\t\trevisionMetadata: RevisionMetadataSource,\n\t): TChangeset;\n}\n\n/**\n * @internal\n */\nexport interface TaggedChange<TChangeset> {\n\treadonly revision: RevisionTag | undefined;\n\t/**\n\t * When populated, indicates that the changeset is a rollback for the purpose of a rebase sandwich.\n\t * The value corresponds to the `revision` of the original changeset being rolled back.\n\t */\n\treadonly rollbackOf?: RevisionTag;\n\treadonly change: TChangeset;\n}\n\nexport function mapTaggedChange<TIn, TOut>(\n\tinput: TaggedChange<TIn>,\n\tchange: TOut,\n): TaggedChange<TOut> {\n\treturn { ...input, change };\n}\n\n/**\n * A callback that returns the index of the changeset associated with the given RevisionTag among the changesets being\n * composed or rebased. This index is solely meant to communicate relative ordering, and is only valid within the scope of the\n * compose or rebase operation.\n *\n * During composition, the index reflects the order of the changeset within the overall composed changeset that is\n * being produced.\n *\n * During rebase, the indices of the base changes are all lower than the indices of the change being rebased.\n * @internal\n */\nexport type RevisionIndexer = (tag: RevisionTag) => number | undefined;\n\n/**\n * @internal\n */\nexport interface RevisionMetadataSource {\n\treadonly getIndex: RevisionIndexer;\n\treadonly tryGetInfo: (tag: RevisionTag | undefined) => RevisionInfo | undefined;\n\treadonly hasRollback: (tag: RevisionTag) => boolean;\n}\n\n/**\n * @internal\n */\nexport interface RevisionInfo {\n\treadonly revision: RevisionTag;\n\t/**\n\t * When populated, indicates that the changeset is a rollback for the purpose of a rebase sandwich.\n\t * The value corresponds to the `revision` of the original changeset being rolled back.\n\t */\n\treadonly rollbackOf?: RevisionTag;\n}\n\nexport function tagChange<T>(change: T, revision: RevisionTag | undefined): TaggedChange<T> {\n\treturn { revision, change };\n}\n\nexport function tagRollbackInverse<T>(\n\tinverseChange: T,\n\trevision: RevisionTag | undefined,\n\trollbackOf: RevisionTag | undefined,\n): TaggedChange<T> {\n\treturn {\n\t\trevision,\n\t\tchange: inverseChange,\n\t\trollbackOf,\n\t};\n}\n\nexport function makeAnonChange<T>(change: T): TaggedChange<T> {\n\treturn { revision: undefined, change };\n}\n\nexport interface FinalChange {\n\treadonly status: FinalChangeStatus;\n}\n\nexport enum FinalChangeStatus {\n\tconflicted,\n\trebased,\n\tcommuted,\n}\n"]}

package/lib/core/rebase/index.d.ts

@@ -0,0 +1,9 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+export { assertIsRevisionTag, areEqualChangeAtomIds, mintRevisionTag, isRevisionTag, mintCommit, GraphCommit, RevisionTag, RevisionTagSchema, EncodedRevisionTag, EncodedChangeAtomId, ChangesetLocalId, ChangeAtomId, ChangeAtomIdMap, SessionId, SessionIdSchema, } from "./types";
+export { ChangeRebaser, FinalChange, FinalChangeStatus, makeAnonChange, tagChange, mapTaggedChange, tagRollbackInverse, TaggedChange, RevisionMetadataSource, RevisionInfo, } from "./changeRebaser";
+export { Exception, Failure, noFailure, OutputType, verifyChangeRebaser, Violation, } from "./verifyChangeRebaser";
+export { findAncestor, findCommonAncestor, rebaseBranch, BranchRebaseResult, rebaseChange, rebaseChangeOverChanges, revisionMetadataSourceFromInfo, } from "./utils";
+//# sourceMappingURL=index.d.ts.map

package/lib/core/rebase/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/rebase/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACN,mBAAmB,EACnB,qBAAqB,EACrB,eAAe,EACf,aAAa,EACb,UAAU,EACV,WAAW,EACX,WAAW,EACX,iBAAiB,EACjB,kBAAkB,EAClB,mBAAmB,EACnB,gBAAgB,EAChB,YAAY,EACZ,eAAe,EACf,SAAS,EACT,eAAe,GACf,MAAM,SAAS,CAAC;AACjB,OAAO,EACN,aAAa,EACb,WAAW,EACX,iBAAiB,EACjB,cAAc,EACd,SAAS,EACT,eAAe,EACf,kBAAkB,EAClB,YAAY,EACZ,sBAAsB,EACtB,YAAY,GACZ,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACN,SAAS,EACT,OAAO,EACP,SAAS,EACT,UAAU,EACV,mBAAmB,EACnB,SAAS,GACT,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACN,YAAY,EACZ,kBAAkB,EAClB,YAAY,EACZ,kBAAkB,EAClB,YAAY,EACZ,uBAAuB,EACvB,8BAA8B,GAC9B,MAAM,SAAS,CAAC"}

package/lib/core/rebase/index.js

@@ -0,0 +1,9 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+export { assertIsRevisionTag, areEqualChangeAtomIds, mintRevisionTag, isRevisionTag, mintCommit, RevisionTagSchema, SessionIdSchema, } from "./types";
+export { FinalChangeStatus, makeAnonChange, tagChange, mapTaggedChange, tagRollbackInverse, } from "./changeRebaser";
+export { noFailure, verifyChangeRebaser, } from "./verifyChangeRebaser";
+export { findAncestor, findCommonAncestor, rebaseBranch, rebaseChange, rebaseChangeOverChanges, revisionMetadataSourceFromInfo, } from "./utils";
+//# sourceMappingURL=index.js.map

package/lib/core/rebase/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/rebase/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACN,mBAAmB,EACnB,qBAAqB,EACrB,eAAe,EACf,aAAa,EACb,UAAU,EAGV,iBAAiB,EAOjB,eAAe,GACf,MAAM,SAAS,CAAC;AACjB,OAAO,EAGN,iBAAiB,EACjB,cAAc,EACd,SAAS,EACT,eAAe,EACf,kBAAkB,GAIlB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAGN,SAAS,EAET,mBAAmB,GAEnB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACN,YAAY,EACZ,kBAAkB,EAClB,YAAY,EAEZ,YAAY,EACZ,uBAAuB,EACvB,8BAA8B,GAC9B,MAAM,SAAS,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nexport {\n\tassertIsRevisionTag,\n\tareEqualChangeAtomIds,\n\tmintRevisionTag,\n\tisRevisionTag,\n\tmintCommit,\n\tGraphCommit,\n\tRevisionTag,\n\tRevisionTagSchema,\n\tEncodedRevisionTag,\n\tEncodedChangeAtomId,\n\tChangesetLocalId,\n\tChangeAtomId,\n\tChangeAtomIdMap,\n\tSessionId,\n\tSessionIdSchema,\n} from \"./types\";\nexport {\n\tChangeRebaser,\n\tFinalChange,\n\tFinalChangeStatus,\n\tmakeAnonChange,\n\ttagChange,\n\tmapTaggedChange,\n\ttagRollbackInverse,\n\tTaggedChange,\n\tRevisionMetadataSource,\n\tRevisionInfo,\n} from \"./changeRebaser\";\nexport {\n\tException,\n\tFailure,\n\tnoFailure,\n\tOutputType,\n\tverifyChangeRebaser,\n\tViolation,\n} from \"./verifyChangeRebaser\";\nexport {\n\tfindAncestor,\n\tfindCommonAncestor,\n\trebaseBranch,\n\tBranchRebaseResult,\n\trebaseChange,\n\trebaseChangeOverChanges,\n\trevisionMetadataSourceFromInfo,\n} from \"./utils\";\n"]}

package/lib/core/rebase/types.d.ts

@@ -0,0 +1,93 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { StableId } from "@fluidframework/id-compressor";
+import { Brand, NestedMap, RangeMap } from "../../util";
+/**
+ * The identifier for a particular session/user/client that can generate `GraphCommit`s
+ */
+export type SessionId = string;
+export declare const SessionIdSchema: import("@sinclair/typebox").TUnsafe<string>;
+/**
+ * A unique identifier for a commit. Commits that have been rebased, but are semantically
+ * the same, will share the same revision tag.
+ * @internal
+ */
+export type RevisionTag = StableId;
+export type EncodedRevisionTag = Brand<string, "EncodedRevisionTag">;
+export declare const RevisionTagSchema: import("@sinclair/typebox").TUnsafe<EncodedRevisionTag>;
+/**
+ * An ID which is unique within a revision of a `ModularChangeset`.
+ * A `ModularChangeset` which is a composition of multiple revisions may contain duplicate `ChangesetLocalId`s,
+ * but they are unique when qualified by the revision of the change they are used in.
+ * @internal
+ */
+export type ChangesetLocalId = Brand<number, "ChangesetLocalId">;
+/**
+ * A globally unique ID for an atom of change, or a node associated with the atom of change.
+ * @internal
+ *
+ * @privateRemarks
+ * TODO: Rename this to be more general.
+ */
+export interface ChangeAtomId {
+    /**
+     * Uniquely identifies the changeset within which the change was made.
+     * Only undefined when referring to an anonymous changesets.
+     */
+    readonly revision?: RevisionTag;
+    /**
+     * Uniquely identifies, in the scope of the changeset, the change made to the field.
+     */
+    readonly localId: ChangesetLocalId;
+}
+export interface EncodedChangeAtomId {
+    readonly revision?: EncodedRevisionTag;
+    readonly localId: ChangesetLocalId;
+}
+/**
+ * @internal
+ */
+export type ChangeAtomIdMap<T> = NestedMap<RevisionTag | undefined, ChangesetLocalId, T>;
+/**
+ * @internal
+ */
+export type ChangeAtomIdRangeMap<T> = Map<RevisionTag | undefined, RangeMap<T>>;
+/**
+ * @returns true iff `a` and `b` are the same.
+ */
+export declare function areEqualChangeAtomIds(a: ChangeAtomId, b: ChangeAtomId): boolean;
+/**
+ * @returns a `RevisionTag` from the given string, or fails if the string is not a valid `RevisionTag`
+ */
+export declare function assertIsRevisionTag(revision: string): RevisionTag;
+/**
+ * @returns true iff the given string is a valid `RevisionTag`
+ */
+export declare function isRevisionTag(revision: string): revision is RevisionTag;
+/**
+ * @returns a random, universally unique `RevisionTag`
+ */
+export declare function mintRevisionTag(): RevisionTag;
+/**
+ * A node in a graph of commits. A commit's parent is the commit on which it was based.
+ */
+export interface GraphCommit<TChange> {
+    /** The tag for this commit. If this commit is rebased, the corresponding rebased commit will retain this tag. */
+    readonly revision: RevisionTag;
+    /** The change that will result from applying this commit */
+    readonly change: TChange;
+    /** The parent of this commit, on whose change this commit's change is based */
+    readonly parent?: GraphCommit<TChange>;
+    /** The inverse of this commit */
+    inverse?: TChange;
+}
+/**
+ * Creates a new graph commit object. This is useful for creating copies of commits with different parentage.
+ * @param parent - the parent of the new commit
+ * @param commit - the contents of the new commit object
+ * @returns the new commit object
+ */
+export declare function mintCommit<TChange>(parent: GraphCommit<TChange>, commit: Omit<GraphCommit<TChange>, "parent">): GraphCommit<TChange>;
+//# sourceMappingURL=types.d.ts.map

package/lib/core/rebase/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/core/rebase/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAc,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAuC,MAAM,YAAY,CAAC;AAE7F;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC;AAC/B,eAAO,MAAM,eAAe,6CAAiC,CAAC;AAE9D;;;;GAIG;AAEH,MAAM,MAAM,WAAW,GAAG,QAAQ,CAAC;AACnC,MAAM,MAAM,kBAAkB,GAAG,KAAK,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;AACrE,eAAO,MAAM,iBAAiB,yDAA0C,CAAC;AAEzE;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GAAG,KAAK,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;AAEjE;;;;;;GAMG;AACH,MAAM,WAAW,YAAY;IAC5B;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,WAAW,CAAC;IAChC;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,gBAAgB,CAAC;CACnC;AAED,MAAM,WAAW,mBAAmB;IACnC,QAAQ,CAAC,QAAQ,CAAC,EAAE,kBAAkB,CAAC;IACvC,QAAQ,CAAC,OAAO,EAAE,gBAAgB,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI,SAAS,CAAC,WAAW,GAAG,SAAS,EAAE,gBAAgB,EAAE,CAAC,CAAC,CAAC;AAEzF;;GAEG;AACH,MAAM,MAAM,oBAAoB,CAAC,CAAC,IAAI,GAAG,CAAC,WAAW,GAAG,SAAS,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;AAEhF;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,GAAG,OAAO,CAE/E;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,CAGjE;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,QAAQ,IAAI,WAAW,CAEvE;AAED;;GAEG;AACH,wBAAgB,eAAe,IAAI,WAAW,CAE7C;AAED;;GAEG;AACH,MAAM,WAAW,WAAW,CAAC,OAAO;IACnC,iHAAiH;IACjH,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC;IAC/B,4DAA4D;IAC5D,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,+EAA+E;IAC/E,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC;IACvC,iCAAiC;IACjC,OAAO,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;;GAKG;AAGH,wBAAgB,UAAU,CAAC,OAAO,EACjC,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,EAC5B,MAAM,EAAE,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,GAC1C,WAAW,CAAC,OAAO,CAAC,CAOtB"}

package/lib/core/rebase/types.js

@@ -0,0 +1,51 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { assert } from "@fluidframework/core-utils";
+import { isStableId } from "@fluidframework/id-compressor";
+import { brandedStringType, generateStableId } from "../../util";
+export const SessionIdSchema = brandedStringType();
+export const RevisionTagSchema = brandedStringType();
+/**
+ * @returns true iff `a` and `b` are the same.
+ */
+export function areEqualChangeAtomIds(a, b) {
+    return a.localId === b.localId && a.revision === b.revision;
+}
+/**
+ * @returns a `RevisionTag` from the given string, or fails if the string is not a valid `RevisionTag`
+ */
+export function assertIsRevisionTag(revision) {
+    assert(isRevisionTag(revision), 0x577 /* Expected revision to be valid RevisionTag */);
+    return revision;
+}
+/**
+ * @returns true iff the given string is a valid `RevisionTag`
+ */
+export function isRevisionTag(revision) {
+    return isStableId(revision);
+}
+/**
+ * @returns a random, universally unique `RevisionTag`
+ */
+export function mintRevisionTag() {
+    return generateStableId();
+}
+/**
+ * Creates a new graph commit object. This is useful for creating copies of commits with different parentage.
+ * @param parent - the parent of the new commit
+ * @param commit - the contents of the new commit object
+ * @returns the new commit object
+ */
+// Note that this function is synchronous, and therefore it is not a Promise.
+// However, it is still a strong commit-mint.
+export function mintCommit(parent, commit) {
+    const { revision, change } = commit;
+    return {
+        revision,
+        change,
+        parent,
+    };
+}
+//# sourceMappingURL=types.js.map

package/lib/core/rebase/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/core/rebase/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AACpD,OAAO,EAAE,UAAU,EAAY,MAAM,+BAA+B,CAAC;AACrE,OAAO,EAA8B,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAM7F,MAAM,CAAC,MAAM,eAAe,GAAG,iBAAiB,EAAa,CAAC;AAU9D,MAAM,CAAC,MAAM,iBAAiB,GAAG,iBAAiB,EAAsB,CAAC;AA4CzE;;GAEG;AACH,MAAM,UAAU,qBAAqB,CAAC,CAAe,EAAE,CAAe;IACrE,OAAO,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,OAAO,IAAI,CAAC,CAAC,QAAQ,KAAK,CAAC,CAAC,QAAQ,CAAC;AAC7D,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,mBAAmB,CAAC,QAAgB;IACnD,MAAM,CAAC,aAAa,CAAC,QAAQ,CAAC,EAAE,KAAK,CAAC,+CAA+C,CAAC,CAAC;IACvF,OAAO,QAAQ,CAAC;AACjB,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,aAAa,CAAC,QAAgB;IAC7C,OAAO,UAAU,CAAC,QAAQ,CAAC,CAAC;AAC7B,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,eAAe;IAC9B,OAAO,gBAAgB,EAAE,CAAC;AAC3B,CAAC;AAgBD;;;;;GAKG;AACH,6EAA6E;AAC7E,6CAA6C;AAC7C,MAAM,UAAU,UAAU,CACzB,MAA4B,EAC5B,MAA4C;IAE5C,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC;IACpC,OAAO;QACN,QAAQ;QACR,MAAM;QACN,MAAM;KACN,CAAC;AACH,CAAC","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 { isStableId, StableId } from \"@fluidframework/id-compressor\";\nimport { Brand, NestedMap, RangeMap, brandedStringType, generateStableId } from \"../../util\";\n\n/**\n * The identifier for a particular session/user/client that can generate `GraphCommit`s\n */\nexport type SessionId = string;\nexport const SessionIdSchema = brandedStringType<SessionId>();\n\n/**\n * A unique identifier for a commit. Commits that have been rebased, but are semantically\n * the same, will share the same revision tag.\n * @internal\n */\n// TODO: These can be compressed by an `IdCompressor` in the future\nexport type RevisionTag = StableId;\nexport type EncodedRevisionTag = Brand<string, \"EncodedRevisionTag\">;\nexport const RevisionTagSchema = brandedStringType<EncodedRevisionTag>();\n\n/**\n * An ID which is unique within a revision of a `ModularChangeset`.\n * A `ModularChangeset` which is a composition of multiple revisions may contain duplicate `ChangesetLocalId`s,\n * but they are unique when qualified by the revision of the change they are used in.\n * @internal\n */\nexport type ChangesetLocalId = Brand<number, \"ChangesetLocalId\">;\n\n/**\n * A globally unique ID for an atom of change, or a node associated with the atom of change.\n * @internal\n *\n * @privateRemarks\n * TODO: Rename this to be more general.\n */\nexport interface ChangeAtomId {\n\t/**\n\t * Uniquely identifies the changeset within which the change was made.\n\t * Only undefined when referring to an anonymous changesets.\n\t */\n\treadonly revision?: RevisionTag;\n\t/**\n\t * Uniquely identifies, in the scope of the changeset, the change made to the field.\n\t */\n\treadonly localId: ChangesetLocalId;\n}\n\nexport interface EncodedChangeAtomId {\n\treadonly revision?: EncodedRevisionTag;\n\treadonly localId: ChangesetLocalId;\n}\n\n/**\n * @internal\n */\nexport type ChangeAtomIdMap<T> = NestedMap<RevisionTag | undefined, ChangesetLocalId, T>;\n\n/**\n * @internal\n */\nexport type ChangeAtomIdRangeMap<T> = Map<RevisionTag | undefined, RangeMap<T>>;\n\n/**\n * @returns true iff `a` and `b` are the same.\n */\nexport function areEqualChangeAtomIds(a: ChangeAtomId, b: ChangeAtomId): boolean {\n\treturn a.localId === b.localId && a.revision === b.revision;\n}\n\n/**\n * @returns a `RevisionTag` from the given string, or fails if the string is not a valid `RevisionTag`\n */\nexport function assertIsRevisionTag(revision: string): RevisionTag {\n\tassert(isRevisionTag(revision), 0x577 /* Expected revision to be valid RevisionTag */);\n\treturn revision;\n}\n\n/**\n * @returns true iff the given string is a valid `RevisionTag`\n */\nexport function isRevisionTag(revision: string): revision is RevisionTag {\n\treturn isStableId(revision);\n}\n\n/**\n * @returns a random, universally unique `RevisionTag`\n */\nexport function mintRevisionTag(): RevisionTag {\n\treturn generateStableId();\n}\n\n/**\n * A node in a graph of commits. A commit's parent is the commit on which it was based.\n */\nexport interface GraphCommit<TChange> {\n\t/** The tag for this commit. If this commit is rebased, the corresponding rebased commit will retain this tag. */\n\treadonly revision: RevisionTag;\n\t/** The change that will result from applying this commit */\n\treadonly change: TChange;\n\t/** The parent of this commit, on whose change this commit's change is based */\n\treadonly parent?: GraphCommit<TChange>;\n\t/** The inverse of this commit */\n\tinverse?: TChange;\n}\n\n/**\n * Creates a new graph commit object. This is useful for creating copies of commits with different parentage.\n * @param parent - the parent of the new commit\n * @param commit - the contents of the new commit object\n * @returns the new commit object\n */\n// Note that this function is synchronous, and therefore it is not a Promise.\n// However, it is still a strong commit-mint.\nexport function mintCommit<TChange>(\n\tparent: GraphCommit<TChange>,\n\tcommit: Omit<GraphCommit<TChange>, \"parent\">,\n): GraphCommit<TChange> {\n\tconst { revision, change } = commit;\n\treturn {\n\t\trevision,\n\t\tchange,\n\t\tparent,\n\t};\n}\n"]}

package/lib/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/lib/core/rebase/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/core/rebase/utils.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EACN,aAAa,EACb,YAAY,EACZ,sBAAsB,EACtB,YAAY,EAEZ,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,WAAW,EAA4C,MAAM,SAAS,CAAC;AAEhF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,cAAc,CAAC,OAAO;IACtC;;;;OAIG;IACH,oBAAoB,EAAE,WAAW,CAAC,OAAO,CAAC,EAAE,CAAC;IAC7C;;;;OAIG;IACH,aAAa,EAAE,WAAW,CAAC,OAAO,CAAC,EAAE,CAAC;IACtC;;;;OAIG;IACH,aAAa,EAAE,WAAW,CAAC,OAAO,CAAC,EAAE,CAAC;CACtC;AAED,MAAM,WAAW,kBAAkB,CAAC,OAAO;IAC1C;;OAEG;IACH,QAAQ,CAAC,aAAa,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC;IAC7C;;OAEG;IACH,QAAQ,CAAC,YAAY,EAAE,OAAO,GAAG,SAAS,CAAC;IAC3C;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC,OAAO,CAAC,CAAC;CAC1C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,YAAY,CAAC,OAAO,EACnC,aAAa,EAAE,aAAa,CAAC,OAAO,CAAC,EACrC,UAAU,EAAE,WAAW,CAAC,OAAO,CAAC,EAChC,UAAU,EAAE,WAAW,CAAC,OAAO,CAAC,GAC9B,kBAAkB,CAAC,OAAO,CAAC,CAAC;AAE/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,YAAY,CAAC,OAAO,EACnC,aAAa,EAAE,aAAa,CAAC,OAAO,CAAC,EACrC,UAAU,EAAE,WAAW,CAAC,OAAO,CAAC,EAChC,YAAY,EAAE,WAAW,CAAC,OAAO,CAAC,EAClC,UAAU,EAAE,WAAW,CAAC,OAAO,CAAC,GAC9B,kBAAkB,CAAC,OAAO,CAAC,CAAC;AA6H/B;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,OAAO,EACnC,aAAa,EAAE,aAAa,CAAC,OAAO,CAAC,EACrC,MAAM,EAAE,OAAO,EACf,UAAU,EAAE,WAAW,CAAC,OAAO,CAAC,EAChC,UAAU,EAAE,WAAW,CAAC,OAAO,CAAC,GAC9B,OAAO,CAWT;AAED;;GAEG;AACH,wBAAgB,8BAA8B,CAC7C,QAAQ,EAAE,SAAS,YAAY,EAAE,GAC/B,sBAAsB,CAkBxB;AAED,wBAAgB,uBAAuB,CAAC,OAAO,EAC9C,aAAa,EAAE,aAAa,CAAC,OAAO,CAAC,EACrC,cAAc,EAAE,OAAO,EACvB,mBAAmB,EAAE,YAAY,CAAC,OAAO,CAAC,EAAE,WAU5C;AAsCD;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS;IAAE,MAAM,CAAC,EAAE,CAAC,CAAA;CAAE,EACpD,UAAU,EAAE,CAAC,GAAG,CAAC,UAAU,EAAE,CAAC,EAAE,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,GACzC,CAAC,CAAC;AACL;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS;IAAE,MAAM,CAAC,EAAE,CAAC,CAAA;CAAE,EACpD,UAAU,EAAE,CAAC,GAAG,CAAC,UAAU,EAAE,CAAC,GAAG,SAAS,EAAE,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,SAAS,GACjE,CAAC,GAAG,SAAS,CAAC;AACjB;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS;IAAE,MAAM,CAAC,EAAE,CAAC,CAAA;CAAE,EACpD,UAAU,EAAE,CAAC,GAAG,CAAC,UAAU,EAAE,CAAC,GAAG,SAAS,EAAE,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,SAAS,EACnE,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,GAC1B,CAAC,GAAG,SAAS,CAAC;AA0BjB;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS;IAAE,MAAM,CAAC,EAAE,CAAC,CAAA;CAAE,EAC1D,WAAW,EAAE,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC,EAAE,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,SAAS,EACzD,WAAW,EAAE,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC,EAAE,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,SAAS,GACvD,CAAC,GAAG,SAAS,CA+Df"}