@fluidframework/merge-tree 1.2.6 → 2.0.0-dev.1.3.0.96595

package/src/properties.ts

@@ -95,6 +95,7 @@ export function matchProperties(a: PropertySet | undefined, b: PropertySet | und
             return false;
         }
     }
+
     return true;
 }
 

package/src/referencePositions.ts

@@ -4,7 +4,7 @@
  */
 
 import { Stack } from "./collections";
-import { ISegment } from "./mergeTree";
+import { ISegment } from "./mergeTreeNodes";
 import { ReferenceType, ICombiningOp } from "./ops";
 import { PropertySet, MapLike } from "./properties";
 
@@ -63,51 +63,23 @@ export interface ReferencePosition {
     getSegment(): ISegment | undefined;
     getOffset(): number;
     addProperties(newProps: PropertySet, op?: ICombiningOp): void;
-    isLeaf(): boolean;
-
-    /**
-     * @deprecated - use refHasTileLabels
-     */
-    hasTileLabels(): boolean;
-    /**
-     * @deprecated - use refHasRangeLabels
-     */
-    hasRangeLabels(): boolean;
-    /**
-     * @deprecated - use refHasTileLabel
-     */
-    hasTileLabel(label: string): boolean;
-    /**
-     * @deprecated - use refHasRangeLabel
-     */
-    hasRangeLabel(label: string): boolean;
-    /**
-     * @deprecated - use refGetTileLabels
-     */
-    getTileLabels(): string[] | undefined;
-    /**
-     * @deprecated - use refGetRangeLabels
-     */
-    getRangeLabels(): string[] | undefined;
+    isLeaf(): this is ISegment;
 }
 
+/**
+ * @deprecated  for internal use only. public export will be removed.
+ * @internal
+ */
 export type RangeStackMap = MapLike<Stack<ReferencePosition>>;
+
 export const DetachedReferencePosition = -1;
 
 export function minReferencePosition<T extends ReferencePosition>(a: T, b: T): T {
-    if (compareReferencePositions(a, b) < 0) {
-        return a;
-    } else {
-        return b;
-    }
+    return compareReferencePositions(a, b) < 0 ? a : b;
 }
 
 export function maxReferencePosition<T extends ReferencePosition>(a: T, b: T): T {
-    if (compareReferencePositions(a, b) > 0) {
-        return a;
-    } else {
-        return b;
-    }
+    return compareReferencePositions(a, b) > 0 ? a : b;
 }
 
 export function compareReferencePositions(a: ReferencePosition, b: ReferencePosition): number {
@@ -116,12 +88,6 @@ export function compareReferencePositions(a: ReferencePosition, b: ReferencePosi
     if (aSeg === bSeg) {
         return a.getOffset() - b.getOffset();
     } else {
-        if (aSeg === undefined
-            || (bSeg !== undefined &&
-                aSeg.ordinal < bSeg.ordinal)) {
-            return -1;
-        } else {
-            return 1;
-        }
+        return aSeg === undefined || (bSeg !== undefined && aSeg.ordinal < bSeg.ordinal) ? -1 : 1;
     }
 }

package/src/segmentGroupCollection.ts

@@ -4,7 +4,7 @@
  */
 
 import { List, ListMakeHead } from "./collections";
-import { ISegment, SegmentGroup } from "./mergeTree";
+import { ISegment, SegmentGroup } from "./mergeTreeNodes";
 
 export class SegmentGroupCollection {
     private readonly segmentGroups: List<SegmentGroup>;
@@ -30,11 +30,26 @@ export class SegmentGroupCollection {
         return this.segmentGroups.dequeue();
     }
 
+    public pop?(): SegmentGroup | undefined {
+        return this.segmentGroups.pop ? this.segmentGroups.pop() : undefined;
+    }
+
     public clear() {
         this.segmentGroups.clear();
     }
 
     public copyTo(segment: ISegment) {
-        this.segmentGroups.walk((sg) => segment.segmentGroups.enqueue(sg));
+        this.segmentGroups.walk((sg) => segment.segmentGroups.enqueueOnCopy(sg, this.segment));
+    }
+
+    private enqueueOnCopy(segmentGroup: SegmentGroup, sourceSegment: ISegment) {
+        this.enqueue(segmentGroup);
+        if (segmentGroup.previousProps) {
+            // duplicate the previousProps for this segment
+            const index = segmentGroup.segments.indexOf(sourceSegment);
+            if (index !== -1) {
+                segmentGroup.previousProps.push(segmentGroup.previousProps[index]);
+            }
+        }
     }
 }

package/src/segmentPropertiesManager.ts

@@ -6,7 +6,7 @@
  /* eslint-disable @typescript-eslint/no-non-null-assertion */
 
 import { assert } from "@fluidframework/common-utils";
-import { UnassignedSequenceNumber } from "./constants";
+import { UnassignedSequenceNumber, UniversalSequenceNumber } from "./constants";
 import { ICombiningOp, IMergeTreeAnnotateMsg } from "./ops";
 import {
     combine,
@@ -15,6 +15,17 @@ import {
     PropertySet,
 } from "./properties";
 
+export enum PropertiesRollback {
+    /** Not in a rollback */
+    None,
+
+    /** Rollback */
+    Rollback,
+
+    /** Rollback of a rewrite */
+    Rewrite,
+}
+
 export class PropertiesManager {
     private pendingKeyUpdateCount: MapLike<number> | undefined;
     private pendingRewriteCount: number;
@@ -24,11 +35,20 @@ export class PropertiesManager {
     }
 
     public ackPendingProperties(annotateOp: IMergeTreeAnnotateMsg) {
-        if (annotateOp.combiningOp && annotateOp.combiningOp.name === "rewrite") {
+        const rewrite = !!annotateOp.combiningOp && annotateOp.combiningOp.name === "rewrite";
+        this.decrementPendingCounts(rewrite, annotateOp.props);
+    }
+
+    private decrementPendingCounts(rewrite: boolean, props: PropertySet) {
+        if (rewrite) {
             this.pendingRewriteCount--;
         }
-        for (const key of Object.keys(annotateOp.props)) {
+        for (const key of Object.keys(props)) {
             if (this.pendingKeyUpdateCount?.[key] !== undefined) {
+                if (rewrite && props[key] === null) {
+                    // We don't track the pending count for this redundant case
+                    continue;
+                }
                 assert(this.pendingKeyUpdateCount[key] > 0,
                     0x05c /* "Trying to update more annotate props than do exist!" */);
                 this.pendingKeyUpdateCount[key]--;
@@ -45,21 +65,35 @@ export class PropertiesManager {
         newProps: PropertySet,
         op?: ICombiningOp,
         seq?: number,
-        collaborating: boolean = false): PropertySet | undefined {
+        collaborating: boolean = false,
+        rollback: PropertiesRollback = PropertiesRollback.None): PropertySet | undefined {
         if (!this.pendingKeyUpdateCount) {
             this.pendingKeyUpdateCount = createMap<number>();
         }
 
         // There are outstanding local rewrites, so block all non-local changes
-        if (this.pendingRewriteCount > 0 && seq !== UnassignedSequenceNumber && collaborating) {
+        if (this.pendingRewriteCount > 0 && seq !== UnassignedSequenceNumber && seq !== UniversalSequenceNumber
+            && collaborating) {
             return undefined;
         }
 
+        // Clean up counts for rolled back edits before modifying oldProps
+        if (collaborating) {
+            if (rollback === PropertiesRollback.Rollback) {
+                this.decrementPendingCounts(false, newProps);
+            } else if (rollback === PropertiesRollback.Rewrite) {
+                // oldProps is the correct props for tracking counts on rewrite because the ones in newProps include
+                // those that were implicitly cleared by the rewrite for which we don't track pending counts.
+                this.decrementPendingCounts(true, oldProps);
+            }
+        }
+
         const rewrite = (op && op.name === "rewrite");
         const combiningOp = !rewrite ? op ? op : undefined : undefined;
 
         const shouldModifyKey = (key: string): boolean => {
             if (seq === UnassignedSequenceNumber
+                || seq === UniversalSequenceNumber
                 || this.pendingKeyUpdateCount?.[key] === undefined
                 || combiningOp) {
                 return true;
@@ -87,6 +121,11 @@ export class PropertiesManager {
         for (const key of Object.keys(newProps)) {
             if (collaborating) {
                 if (seq === UnassignedSequenceNumber) {
+                    if (rewrite && newProps[key] === null) {
+                        // This case has already been handled above and
+                        // we don't want to track the pending count for it in case of rollback
+                        continue;
+                    }
                     if (this.pendingKeyUpdateCount?.[key] === undefined) {
                         this.pendingKeyUpdateCount[key] = 0;
                     }
@@ -97,14 +136,9 @@ export class PropertiesManager {
             }
 
             const previousValue: any = oldProps[key];
-            // The delta should be null if undefined, as thats how we encode delete
+            // The delta should be null if undefined, as that's how we encode delete
             deltas[key] = (previousValue === undefined) ? null : previousValue;
-            let newValue: any;
-            if (combiningOp) {
-                newValue = combine(combiningOp, previousValue, newValue, seq);
-            } else {
-                newValue = newProps[key];
-            }
+            const newValue = combiningOp ? combine(combiningOp, previousValue, undefined, seq) : newProps[key];
             if (newValue === null) {
                 // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
                 delete oldProps[key];

package/src/snapshotChunks.ts

@@ -63,7 +63,8 @@ export interface IJSONSegmentWithMergeInfo {
     client?: string;
     seq?: number;
     /**
-     * @deprecated - use removedClientIds instead. this only exists for back-compat
+     * @deprecated Use {@link IJSONSegmentWithMergeInfo.removedClientIds} instead.
+     * This only exists for backwards compatability.
      */
     removedClient?: string;
     removedClientIds?: string[];

package/src/snapshotLoader.ts

@@ -14,7 +14,7 @@ import { ITelemetryLogger } from "@fluidframework/common-definitions";
 import { AttachState } from "@fluidframework/container-definitions";
 import { Client } from "./client";
 import { NonCollabClient, UniversalSequenceNumber } from "./constants";
-import { ISegment, MergeTree } from "./mergeTree";
+import { ISegment } from "./mergeTreeNodes";
 import { IJSONSegment } from "./ops";
 import {
     IJSONSegmentWithMergeInfo,
@@ -23,6 +23,7 @@ import {
 } from "./snapshotChunks";
 import { SnapshotV1 } from "./snapshotV1";
 import { SnapshotLegacy } from "./snapshotlegacy";
+import { MergeTree } from "./mergeTree";
 
 export class SnapshotLoader {
     private readonly logger: ITelemetryLogger;

package/src/snapshotV1.ts

@@ -14,8 +14,7 @@ import { SummaryTreeBuilder } from "@fluidframework/runtime-utils";
 import { UnassignedSequenceNumber } from "./constants";
 import {
     ISegment,
-    MergeTree,
-} from "./mergeTree";
+} from "./mergeTreeNodes";
 import {
     matchProperties,
     PropertySet,
@@ -29,6 +28,7 @@ import {
     serializeAsMaxSupportedVersion,
 } from "./snapshotChunks";
 import { SnapshotLegacy } from "./snapshotlegacy";
+import { MergeTree } from "./mergeTree";
 
 export class SnapshotV1 {
     // Split snapshot into two entries - headers (small) and body (overflow) for faster loading initial content
@@ -200,7 +200,7 @@ export class SnapshotV1 {
                     prev = segment;
                 }
             } else {
-                // This segment needs to preserve it's metadata as it may be referenced by future ops.  It's ineligible
+                // This segment needs to preserve its metadata as it may be referenced by future ops.  It's ineligible
                 // for coalescing, so emit the 'prev' segment now (if any).
                 pushSeg(prev);
                 prev = undefined;

package/src/snapshotlegacy.ts

@@ -16,14 +16,14 @@ import { SummaryTreeBuilder } from "@fluidframework/runtime-utils";
 import { NonCollabClient, UnassignedSequenceNumber } from "./constants";
 import {
     ISegment,
-    MergeTree,
-} from "./mergeTree";
+} from "./mergeTreeNodes";
 import { IJSONSegment } from "./ops";
 import { matchProperties } from "./properties";
 import {
     MergeTreeChunkLegacy,
     serializeAsMinSupportedVersion,
 } from "./snapshotChunks";
+import { MergeTree } from "./mergeTree";
 
 interface SnapshotHeader {
     chunkCount?: number;
@@ -36,6 +36,10 @@ interface SnapshotHeader {
     minSeq?: number;
 }
 
+/**
+ * @deprecated  for internal use only. public export will be removed.
+ * @internal
+ */
 export class SnapshotLegacy {
     public static readonly header = "header";
     public static readonly body = "body";

package/src/sortedSegmentSet.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { ISegment } from "./mergeTree";
+import { ISegment } from "./mergeTreeNodes";
 
 /**
  * Stores a unique and sorted set of segments, or objects with segments

package/src/textSegment.ts

@@ -3,8 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { IIntegerRange } from "./base";
-import { BaseSegment, ISegment, Marker, MergeTree } from "./mergeTree";
+import { BaseSegment, ISegment, Marker } from "./mergeTreeNodes";
 import { IJSONSegment } from "./ops";
 import { PropertySet } from "./properties";
 import { LocalReferenceCollection } from "./localReference";
@@ -121,159 +120,13 @@ export class TextSegment extends BaseSegment {
     }
 }
 
-interface ITextAccumulator {
-    textSegment: TextSegment;
-    placeholder?: string;
-    parallelArrays?: boolean;
-}
-
-interface ITextAndMarkerAccumulator extends ITextAccumulator {
-    parallelArrays: true;
-    parallelText: string[];
-    parallelMarkers: Marker[];
-    parallelMarkerLabel: string;
-    tagsInProgress: string[];
-}
-
-function isTextAndMarkerAccumulator(accum: ITextAccumulator): accum is ITextAndMarkerAccumulator {
-    return accum.parallelArrays === true;
-}
-
-type ITextAccumulatorType = ITextAccumulator | ITextAndMarkerAccumulator;
-export class MergeTreeTextHelper {
-    constructor(private readonly mergeTree: MergeTree) { }
-
-    public getTextAndMarkers(refSeq: number, clientId: number, label: string, start?: number, end?: number) {
-        const range = this.getValidRange(start, end, refSeq, clientId);
-        const accum: ITextAndMarkerAccumulator = {
-            parallelArrays: true,
-            parallelMarkerLabel: label,
-            parallelMarkers: [],
-            parallelText: [],
-            tagsInProgress: [],
-            textSegment: new TextSegment(""),
-        };
-
-        this.mergeTree.mapRange<ITextAndMarkerAccumulator>(
-            { leaf: this.gatherText },
-            refSeq,
-            clientId,
-            accum,
-            range.start,
-            range.end);
-
-        return { parallelText: accum.parallelText, parallelMarkers: accum.parallelMarkers };
-    }
-
-    public getText(refSeq: number, clientId: number, placeholder = "", start?: number, end?: number) {
-        const range = this.getValidRange(start, end, refSeq, clientId);
-
-        const accum: ITextAccumulator = { textSegment: new TextSegment(""), placeholder };
-
-        this.mergeTree.mapRange<ITextAccumulator>(
-            { leaf: this.gatherText },
-            refSeq,
-            clientId,
-            accum,
-            range.start,
-            range.end);
-        return accum.textSegment.text;
-    }
-
-    private getValidRange(
-        start: number | undefined,
-        end: number | undefined,
-        refSeq: number,
-        clientId: number,
-    ): IIntegerRange {
-        const range: IIntegerRange = {
-            end: end ?? this.mergeTree.getLength(refSeq, clientId),
-            start: start ?? 0,
-        };
-        return range;
-    }
-
-    private readonly gatherText = (segment: ISegment, pos: number, refSeq: number, clientId: number, start: number,
-        end: number, accumText: ITextAccumulatorType) => {
-        let _start = start;
-        if (TextSegment.is(segment)) {
-            let beginTags = "";
-            let endTags = "";
-            if (isTextAndMarkerAccumulator(accumText)) {
-                // TODO: let clients pass in function to get tag
-                const tags = [] as string[];
-                const initTags = [] as string[];
-
-                if (segment.properties?.["font-weight"]) {
-                    tags.push("b");
-                }
-                if (segment.properties?.["text-decoration"]) {
-                    tags.push("u");
-                }
-                const remTags = [] as string[];
-                if (tags.length > 0) {
-                    for (const tag of tags) {
-                        if (!accumText.tagsInProgress.includes(tag)) {
-                            beginTags += `<${tag}>`;
-                            initTags.push(tag);
-                        }
-                    }
-                    for (const accumTag of accumText.tagsInProgress) {
-                        if (!tags.includes(accumTag)) {
-                            endTags += `</${accumTag}>`;
-                            remTags.push(accumTag);
-                        }
-                    }
-                    for (const initTag of initTags.reverse()) {
-                        accumText.tagsInProgress.push(initTag);
-                    }
-                } else {
-                    for (const accumTag of accumText.tagsInProgress) {
-                        endTags += `</${accumTag}>`;
-                        remTags.push(accumTag);
-                    }
-                }
-                for (const remTag of remTags) {
-                    const remdex = accumText.tagsInProgress.indexOf(remTag);
-                    if (remdex >= 0) {
-                        accumText.tagsInProgress.splice(remdex, 1);
-                    }
-                }
-            }
-            accumText.textSegment.text += endTags;
-            accumText.textSegment.text += beginTags;
-            if ((_start <= 0) && (end >= segment.text.length)) {
-                accumText.textSegment.text += segment.text;
-            } else {
-                if (_start < 0) {
-                    _start = 0;
-                }
-                if (end >= segment.text.length) {
-                    accumText.textSegment.text += segment.text.substring(_start);
-                } else {
-                    accumText.textSegment.text += segment.text.substring(_start, end);
-                }
-            }
-        } else {
-            if (accumText.placeholder && (accumText.placeholder.length > 0)) {
-                if (accumText.placeholder === "*") {
-                    const marker = segment as Marker;
-                    accumText.textSegment.text += `\n${marker.toString()}`;
-                } else {
-                    for (let i = 0; i < segment.cachedLength; i++) {
-                        accumText.textSegment.text += accumText.placeholder;
-                    }
-                }
-            } else if (isTextAndMarkerAccumulator(accumText)) {
-                const marker = segment as Marker;
-                if (marker.hasTileLabel(accumText.parallelMarkerLabel)) {
-                    accumText.parallelMarkers.push(marker);
-                    accumText.parallelText.push(accumText.textSegment.text);
-                    accumText.textSegment.text = "";
-                }
-            }
-        }
-
-        return true;
-    };
+export interface IMergeTreeTextHelper{
+    /**
+     * @deprecated If consuming via sequence, use `getTextAndMarkers` exported from `\@fluidframework/sequence`.
+     * Otherwise, define your own accumulation model and use `Client.walkSegments`.
+     */
+    getTextAndMarkers(refSeq: number, clientId: number, label: string, start?: number, end?: number): {
+        parallelText: string[];
+        parallelMarkers: Marker[]; };
+    getText(refSeq: number, clientId: number, placeholder: string, start?: number, end?: number): string;
 }