@fluidframework/merge-tree 0.59.2000-63294 → 0.59.3000-66610

package/src/mergeTree.ts

@@ -50,27 +50,19 @@ import {
     matchProperties,
     PropertySet,
 } from "./properties";
+import {
+    RangeStackMap,
+    ReferencePosition,
+    refGetRangeLabels,
+    refGetTileLabels,
+    refHasRangeLabel,
+    refHasRangeLabels,
+    refHasTileLabel,
+    refHasTileLabels,
+ } from "./referencePositions";
 import { SegmentGroupCollection } from "./segmentGroupCollection";
 import { PropertiesManager } from "./segmentPropertiesManager";
 
-export interface ReferencePosition {
-    properties?: PropertySet;
-    refType: ReferenceType;
-    // True if this reference is a segment.
-    isLeaf(): boolean;
-    getSegment(): ISegment | undefined;
-    getOffset(): number;
-    addProperties(newProps: PropertySet, op?: ICombiningOp): void;
-    hasTileLabels(): boolean;
-    hasRangeLabels(): boolean;
-    hasTileLabel(label: string): boolean;
-    hasRangeLabel(label: string): boolean;
-    getTileLabels(): string[] | undefined;
-    getRangeLabels(): string[] | undefined;
-}
-
-export type RangeStackMap = MapLike<Stack<ReferencePosition>>;
-
 export interface IMergeNodeCommon {
     parent?: IMergeBlock;
     /**
@@ -265,7 +257,7 @@ export class MergeNode implements IMergeNodeCommon {
 }
 
 function addTile(tile: ReferencePosition, tiles: object) {
-    const tileLabels = tile.getTileLabels();
+    const tileLabels = refGetTileLabels(tile);
     if (tileLabels) {
         for (const tileLabel of tileLabels) {
             tiles[tileLabel] = tile;
@@ -274,7 +266,7 @@ function addTile(tile: ReferencePosition, tiles: object) {
 }
 
 function addTileIfNotPresent(tile: ReferencePosition, tiles: object) {
-    const tileLabels = tile.getTileLabels();
+    const tileLabels = refGetTileLabels(tile);
     if (tileLabels) {
         for (const tileLabel of tileLabels) {
             if (tiles[tileLabel] === undefined) {
@@ -345,9 +337,9 @@ function addNodeReferences(
                     addTileIfNotPresent(segment, leftmostTiles);
                 }
                 if (segment.refType & (ReferenceType.NestBegin | ReferenceType.NestEnd)) {
-                    const rangeLabels = segment.getRangeLabels();
+                    const rangeLabels = refGetRangeLabels(segment);
                     if (rangeLabels) {
-                        for (const label of segment.getRangeLabels()!) {
+                        for (const label of rangeLabels) {
                             updateRangeInfo(label, segment);
                         }
                     }
@@ -362,7 +354,7 @@ function addNodeReferences(
                             addTileIfNotPresent(lref, leftmostTiles);
                         }
                         if (lref.refType & (ReferenceType.NestBegin | ReferenceType.NestEnd)) {
-                            for (const label of lref.getRangeLabels()!) {
+                            for (const label of refGetRangeLabels(lref)!) {
                                 updateRangeInfo(label, lref);
                             }
                         }
@@ -622,43 +614,9 @@ export abstract class BaseSegment extends MergeNode implements ISegment {
     protected abstract createSplitSegmentAt(pos: number): BaseSegment | undefined;
 }
 
-export const reservedTileLabelsKey = "referenceTileLabels";
-export const reservedRangeLabelsKey = "referenceRangeLabels";
 export const reservedMarkerIdKey = "markerId";
 export const reservedMarkerSimpleTypeKey = "markerSimpleType";
 
-export const refGetTileLabels = (refPos: ReferencePosition) =>
-    (refPos.refType & ReferenceType.Tile)
-        && refPos.properties ? refPos.properties[reservedTileLabelsKey] as string[] : undefined;
-
-export const refGetRangeLabels = (refPos: ReferencePosition) =>
-    (refPos.refType & (ReferenceType.NestBegin | ReferenceType.NestEnd))
-        && refPos.properties ? refPos.properties[reservedRangeLabelsKey] as string[] : undefined;
-
-export function refHasTileLabel(refPos: ReferencePosition, label: string) {
-    const tileLabels = refPos.getTileLabels();
-    if (tileLabels) {
-        for (const refLabel of tileLabels) {
-            if (label === refLabel) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-
-export function refHasRangeLabel(refPos: ReferencePosition, label: string) {
-    const rangeLabels = refPos.getRangeLabels();
-    if (rangeLabels) {
-        for (const refLabel of rangeLabels) {
-            if (label === refLabel) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-
 export interface IJSONMarkerSegment extends IJSONSegment {
     marker: IMarkerDef;
 }
@@ -728,26 +686,39 @@ export class Marker extends BaseSegment implements ReferencePosition {
         }
     }
 
+    /**
+     * @deprecated - use refHasTileLabels
+     */
     hasTileLabels() {
-        return !!this.getTileLabels();
+        return refHasTileLabels(this);
     }
-
+    /**
+     * @deprecated - use refHasRangeLabels
+     */
     hasRangeLabels() {
-        return !!this.getRangeLabels();
+        return refHasRangeLabels(this);
     }
-
+    /**
+     * @deprecated - use refHasTileLabel
+     */
     hasTileLabel(label: string): boolean {
         return refHasTileLabel(this, label);
     }
-
+    /**
+     * @deprecated - use refHasRangeLabel
+     */
     hasRangeLabel(label: string): boolean {
         return refHasRangeLabel(this, label);
     }
-
+    /**
+     * @deprecated - use refGetTileLabels
+     */
     getTileLabels(): string[] | undefined {
         return refGetTileLabels(this);
     }
-
+    /**
+     * @deprecated - use refGetRangeLabels
+     */
     getRangeLabels(): string[] | undefined {
         return refGetRangeLabels(this);
     }
@@ -774,7 +745,7 @@ export class Marker extends BaseSegment implements ReferencePosition {
         if (id) {
             bbuf += ` (${id}) `;
         }
-        const tileLabels = this.getTileLabels();
+        const tileLabels = refGetTileLabels(this);
         if (tileLabels) {
             lbuf += "tile -- ";
             for (let i = 0, len = tileLabels.length; i < len; i++) {
@@ -785,7 +756,7 @@ export class Marker extends BaseSegment implements ReferencePosition {
                 lbuf += tileLabel;
             }
         }
-        const rangeLabels = this.getRangeLabels();
+        const rangeLabels = refGetRangeLabels(this);
         if (rangeLabels) {
             let rangeKind = "begin";
             if (this.refType & ReferenceType.NestEnd) {
@@ -931,7 +902,7 @@ interface IMarkerSearchRangeInfo {
 
 function applyLeafRangeMarker(marker: Marker, searchInfo: IMarkerSearchRangeInfo) {
     for (const rangeLabel of searchInfo.rangeLabels) {
-        if (marker.hasRangeLabel(rangeLabel)) {
+        if (refHasRangeLabel(marker, rangeLabel)) {
             let currentStack = searchInfo.stacks[rangeLabel];
             if (currentStack === undefined) {
                 currentStack = new Stack<Marker>();
@@ -981,7 +952,7 @@ function recordTileStart(
     end: number,
     searchInfo: IReferenceSearchInfo) {
     if (Marker.is(segment)) {
-        if (segment.hasTileLabel(searchInfo.tileLabel)) {
+        if (refHasTileLabel(segment, searchInfo.tileLabel)) {
             searchInfo.tile = segment;
         }
     }
@@ -994,7 +965,7 @@ function tileShift(
     if (node.isLeaf()) {
         const seg = node;
         if ((searchInfo.mergeTree.localNetLength(seg) > 0) && Marker.is(seg)) {
-            if (seg.hasTileLabel(searchInfo.tileLabel)) {
+            if (refHasTileLabel(seg, searchInfo.tileLabel)) {
                 searchInfo.tile = seg;
             }
         }
@@ -1134,7 +1105,7 @@ export class MergeTree {
                 // and update the block's info.
                 for (let childIndex = 0;
                     childIndex < maxChildren && nodeIndex < nodes.length;   // While we still have children & nodes left
-                    childIndex++ , nodeIndex++                               // Advance to next child & node
+                    childIndex++, nodeIndex++                               // Advance to next child & node
                 ) {
                     // Insert the next node into the current block
                     this.addNode(block, nodes[nodeIndex]);
@@ -1202,11 +1173,13 @@ export class MergeTree {
                         } else {
                             // Notify maintenance event observers that the segment is being unlinked from the MergeTree
                             if (this.mergeTreeMaintenanceCallback) {
-                                this.mergeTreeMaintenanceCallback({
-                                    operation: MergeTreeMaintenanceType.UNLINK,
-                                    deltaSegments: [{ segment }],
-                                },
-                                undefined);
+                                this.mergeTreeMaintenanceCallback(
+                                    {
+                                        operation: MergeTreeMaintenanceType.UNLINK,
+                                        deltaSegments: [{ segment }],
+                                    },
+                                    undefined,
+                                );
                             }
 
                             segment.parent = undefined;
@@ -1223,11 +1196,13 @@ export class MergeTree {
                             if (canAppend) {
                                 prevSegment!.append(segment);
                                 if (this.mergeTreeMaintenanceCallback) {
-                                    this.mergeTreeMaintenanceCallback({
-                                        operation: MergeTreeMaintenanceType.APPEND,
-                                        deltaSegments: [{ segment: prevSegment! }, { segment }],
-                                    },
-                                    undefined);
+                                    this.mergeTreeMaintenanceCallback(
+                                        {
+                                            operation: MergeTreeMaintenanceType.APPEND,
+                                            deltaSegments: [{ segment: prevSegment! }, { segment }],
+                                        },
+                                        undefined,
+                                    );
                                 }
                                 segment.parent = undefined;
                                 segment.trackingCollection.trackingGroups.forEach((tg) => tg.unlink(segment));
@@ -1461,7 +1436,7 @@ export class MergeTree {
                 const segment = node;
                 const removalInfo = toRemovalInfo(segment);
 
-                if(removalInfo !== undefined
+                if (removalInfo !== undefined
                     && removalInfo.removedSeq !== UnassignedSequenceNumber
                     && removalInfo.removedSeq <= refSeq) {
                     // this segment is a tombstone eligible for zamboni
@@ -1485,7 +1460,7 @@ export class MergeTree {
                     // the segment was inserted and removed before the
                     // this context, so it will never exist for this
                     // context
-                    if(removalInfo !== undefined
+                    if (removalInfo !== undefined
                         && removalInfo.removedSeq !== UnassignedSequenceNumber) {
                         return undefined;
                     }
@@ -1707,10 +1682,10 @@ export class MergeTree {
                     nodesToUpdate.push(pendingSegment.parent!);
                 }
                 deltaSegments.push({
-                    segment:pendingSegment,
+                    segment: pendingSegment,
                 });
             });
-            if(this.mergeTreeMaintenanceCallback) {
+            if (this.mergeTreeMaintenanceCallback) {
                 this.mergeTreeMaintenanceCallback(
                     {
                         deltaSegments,
@@ -1874,7 +1849,7 @@ export class MergeTree {
             }
             const backLen = this.nodeLength(backSeg, this.collabWindow.currentSeq, clientId);
             // ignore removed segments
-            if(backLen === undefined) {
+            if (backLen === undefined) {
                 return true;
             }
             // Find the nearest 0 length seg we can insert over, as all other inserts
@@ -1940,7 +1915,7 @@ export class MergeTree {
         remoteClientPosition: number,
         remoteClientRefSeq: number,
         remoteClientId: number): number | undefined {
-        if(remoteClientRefSeq < this.collabWindow.minSeq) {
+        if (remoteClientRefSeq < this.collabWindow.minSeq) {
             return undefined;
         }
 
@@ -2001,9 +1976,9 @@ export class MergeTree {
         const saveIfLocal = (locSegment: ISegment) => {
             // Save segment so can assign sequence number when acked by server
             if (this.collabWindow.collaborating) {
-                if ((locSegment.seq === UnassignedSequenceNumber) &&
-                    (clientId === this.collabWindow.clientId)) {
+                if ((locSegment.seq === UnassignedSequenceNumber) && (clientId === this.collabWindow.clientId)) {
                     segmentGroup = this.addToPendingList(locSegment, segmentGroup, localSeq);
+                    // eslint-disable-next-line @typescript-eslint/brace-style
                 }
                 // LocSegment.seq === 0 when coming from SharedSegmentSequence.loadBody()
                 // In all other cases this has to be true (checked by addToLRUSet):
@@ -2070,7 +2045,7 @@ export class MergeTree {
                 operation: MergeTreeMaintenanceType.SPLIT,
                 deltaSegments: [{ segment }, { segment: next }],
             },
-            undefined);
+                undefined);
         }
 
         return { next };
@@ -2178,7 +2153,7 @@ export class MergeTree {
         for (childIndex = 0; childIndex < block.childCount; childIndex++) {
             child = children[childIndex];
             const len = this.nodeLength(child, refSeq, clientId);
-            if(len === undefined) {
+            if (len === undefined) {
                 // if the seg len in undefined, the segment
                 // will be removed, so should just be skipped for now
                 continue;
@@ -2467,6 +2442,9 @@ export class MergeTree {
         }
     }
 
+    /**
+     * @deprecated - use removeLocalReferencePosition
+     */
     public removeLocalReference(segment: ISegment, lref: LocalReference) {
         if (segment.localRefs) {
             const removedRef = segment.localRefs.removeLocalRef(lref);
@@ -2477,6 +2455,9 @@ export class MergeTree {
         }
     }
 
+    /**
+     * @deprecated - use createLocalReference
+     */
     public addLocalReference(lref: LocalReference) {
         const segment = lref.segment!;
         let localRefs = segment.localRefs;

package/src/referencePositions.ts

@@ -0,0 +1,122 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { Stack } from "./collections";
+import { ISegment } from "./mergeTree";
+import { ReferenceType, ICombiningOp } from "./ops";
+import { PropertySet, MapLike } from "./properties";
+
+export const reservedTileLabelsKey = "referenceTileLabels";
+export const reservedRangeLabelsKey = "referenceRangeLabels";
+
+export const refGetTileLabels = (refPos: ReferencePosition): string[] | undefined =>
+    // eslint-disable-next-line no-bitwise
+    (refPos.refType & ReferenceType.Tile)
+        && refPos.properties ? refPos.properties[reservedTileLabelsKey] as string[] : undefined;
+
+export const refGetRangeLabels = (refPos: ReferencePosition): string[] | undefined =>
+    // eslint-disable-next-line no-bitwise
+    (refPos.refType & (ReferenceType.NestBegin | ReferenceType.NestEnd))
+        && refPos.properties ? refPos.properties[reservedRangeLabelsKey] as string[] : undefined;
+
+export function refHasTileLabel(refPos: ReferencePosition, label: string): boolean {
+    const tileLabels = refGetTileLabels(refPos);
+    if (tileLabels) {
+        for (const refLabel of tileLabels) {
+            if (label === refLabel) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+export function refHasRangeLabel(refPos: ReferencePosition, label: string): boolean {
+    const rangeLabels = refGetRangeLabels(refPos);
+    if (rangeLabels) {
+        for (const refLabel of rangeLabels) {
+            if (label === refLabel) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+export function refHasTileLabels(refPos: ReferencePosition): boolean {
+    return refGetTileLabels(refPos) !== undefined;
+}
+export function refHasRangeLabels(refPos: ReferencePosition): boolean {
+    return refGetRangeLabels(refPos) !== undefined;
+}
+
+export interface ReferencePosition {
+    properties?: PropertySet;
+    refType: ReferenceType;
+
+    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;
+}
+
+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;
+    }
+}
+
+export function maxReferencePosition<T extends ReferencePosition>(a: T, b: T): T {
+    if (compareReferencePositions(a, b) > 0) {
+        return a;
+    } else {
+        return b;
+    }
+}
+
+export function compareReferencePositions(a: ReferencePosition, b: ReferencePosition): number {
+    const aSeg = a.getSegment();
+    const bSeg = b.getSegment();
+    if (aSeg === bSeg) {
+        return a.getOffset() - b.getOffset();
+    } else {
+        if (aSeg === undefined
+            || (bSeg !== undefined &&
+                aSeg.ordinal < bSeg.ordinal)) {
+            return -1;
+        } else {
+            return 1;
+        }
+    }
+}

package/src/snapshotChunks.ts

@@ -20,7 +20,7 @@ export type JsonSegmentSpecs = IJSONSegment | IJSONSegmentWithMergeInfo;
 
 export interface MergeTreeChunkLegacy extends VersionedMergeTreeChunk {
     version: undefined;
-    chunkStartSegmentIndex: number,
+    chunkStartSegmentIndex: number;
     chunkSegmentCount: number;
     chunkLengthChars: number;
     totalLengthChars?: number;
@@ -32,19 +32,19 @@ export interface MergeTreeChunkLegacy extends VersionedMergeTreeChunk {
 }
 
 export interface MergeTreeHeaderChunkMetadata {
-    id: string,
+    id: string;
 }
 
 export interface MergeTreeHeaderMetadata {
-    totalLength: number,
-    totalSegmentCount: number,
-    orderedChunkMetadata: MergeTreeHeaderChunkMetadata[],
-    sequenceNumber: number,
-    minSequenceNumber: number,
+    totalLength: number;
+    totalSegmentCount: number;
+    orderedChunkMetadata: MergeTreeHeaderChunkMetadata[];
+    sequenceNumber: number;
+    minSequenceNumber: number;
 }
 
 export interface MergeTreeChunkV1 extends VersionedMergeTreeChunk {
-    version: "1",
+    version: "1";
     startIndex: number;
     segmentCount: number;
     length: number;

package/src/snapshotLoader.ts

@@ -38,18 +38,18 @@ export class SnapshotLoader {
 
     public async initialize(
         services: IChannelStorageService,
-    ): Promise<{ catchupOpsP: Promise<ISequencedDocumentMessage[]> }> {
+    ): Promise<{ catchupOpsP: Promise<ISequencedDocumentMessage[]>; }> {
         const headerLoadedP =
             services.readBlob(SnapshotLegacy.header).then((header) => {
                 assert(!!header, 0x05f /* "Missing blob header on legacy snapshot!" */);
-                return this.loadHeader(bufferToString(header,"utf8"));
+                return this.loadHeader(bufferToString(header, "utf8"));
             });
 
         const catchupOpsP =
             this.loadBodyAndCatchupOps(headerLoadedP, services);
 
         catchupOpsP.catch(
-            (err)=>this.logger.sendErrorEvent({ eventName: "CatchupOpsLoadFailure" },err));
+            (err) => this.logger.sendErrorEvent({ eventName: "CatchupOpsLoadFailure" }, err));
 
         await headerLoadedP;
 
@@ -111,7 +111,7 @@ export class SnapshotLoader {
             }
             if (spec.removedClientIds !== undefined) {
                 seg.removedClientIds = spec.removedClientIds?.map(
-                    (sid)=> this.client.getOrAddShortClientId(sid));
+                    (sid) => this.client.getOrAddShortClientId(sid));
             }
         } else {
             seg = this.client.specToSegment(spec);

package/src/snapshotV1.ts

@@ -225,7 +225,7 @@ export class SnapshotV1 {
                             ? this.getLongClientId(segment.removedClientIds[0])
                             : undefined;
 
-                    raw.removedClientIds = segment.removedClientIds?.map((id)=>this.getLongClientId(id));
+                    raw.removedClientIds = segment.removedClientIds?.map((id) => this.getLongClientId(id));
                 }
 
             // Sanity check that we are preserving either the seq < minSeq or a removed segment's info.

package/src/snapshotlegacy.ts

@@ -131,7 +131,7 @@ export class SnapshotLegacy {
             segments === chunk1.totalSegmentCount,
             0x05e /* "emit: mismatch in totalSegmentCount" */);
 
-        if(catchUpMsgs !== undefined && catchUpMsgs.length > 0) {
+        if (catchUpMsgs !== undefined && catchUpMsgs.length > 0) {
             builder.addBlob(
                 this.mergeTree.options?.catchUpBlobName ?? SnapshotLegacy.catchupOps,
                 serializer ? serializer.stringify(catchUpMsgs, bind) : JSON.stringify(catchUpMsgs));

package/src/sortedSegmentSet.ts

@@ -15,7 +15,7 @@ import { ISegment } from "./mergeTree";
  * the segments changes. This invariant allows ensure the segments stay ordered and unique, and that new segments
  * can be inserted into that order.
  */
-export class SortedSegmentSet<T extends ISegment | { readonly segment: ISegment } = ISegment> {
+export class SortedSegmentSet<T extends ISegment | { readonly segment: ISegment; } = ISegment> {
     private readonly ordinalSortedItems: T[] = [];
 
     public get size(): number {
@@ -52,7 +52,7 @@ export class SortedSegmentSet<T extends ISegment | { readonly segment: ISegment
     }
 
     private getOrdinal(item: T): string {
-        const maybeObject = item as { readonly segment: ISegment };
+        const maybeObject = item as { readonly segment: ISegment; };
         if (maybeObject && maybeObject.segment) {
             return maybeObject.segment.ordinal;
         }
@@ -61,7 +61,7 @@ export class SortedSegmentSet<T extends ISegment | { readonly segment: ISegment
         return maybeSegment.ordinal;
     }
 
-    private findOrdinalPosition(ordinal: string, start?: number, end?: number): { exists: boolean, index: number } {
+    private findOrdinalPosition(ordinal: string, start?: number, end?: number): { exists: boolean; index: number; } {
         if (this.ordinalSortedItems.length === 0) {
             return { exists: false, index: 0 };
         }