@fluidframework/merge-tree 0.59.2001 → 0.59.3000

package/src/mergeTree.ts

@@ -6,7 +6,7 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 /* eslint-disable @typescript-eslint/consistent-type-assertions */
 
-/* eslint-disable no-bitwise */
+/* eslint-disable @typescript-eslint/prefer-optional-chain, no-bitwise */
 
 import { assert } from "@fluidframework/common-utils";
 import {
@@ -50,26 +50,20 @@ import {
     matchProperties,
     PropertySet,
 } from "./properties";
+import {
+    refTypeIncludesFlag,
+    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>>;
+import { Client } from "./client";
 
 export interface IMergeNodeCommon {
     parent?: IMergeBlock;
@@ -265,7 +259,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 +268,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) {
@@ -302,14 +296,14 @@ function applyStackDelta(currentStackMap: RangeStackMap, deltaStackMap: RangeSta
 }
 
 function applyRangeReference(stack: Stack<ReferencePosition>, delta: ReferencePosition) {
-    if (delta.refType & ReferenceType.NestBegin) {
+    if (refTypeIncludesFlag(delta, ReferenceType.NestBegin)) {
         stack.push(delta);
         return true;
     } else {
         // Assume delta is end reference
         const top = stack.top();
         // TODO: match end with begin
-        if (top && (top.refType & ReferenceType.NestBegin)) {
+        if (top && (refTypeIncludesFlag(top, ReferenceType.NestBegin))) {
             stack.pop();
         } else {
             stack.push(delta);
@@ -340,14 +334,14 @@ function addNodeReferences(
                 if (markerId) {
                     mergeTree.mapIdToSegment(markerId, segment);
                 }
-                if (segment.refType & ReferenceType.Tile) {
+                if (refTypeIncludesFlag(segment, ReferenceType.Tile)) {
                     addTile(segment, rightmostTiles);
                     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);
                         }
                     }
@@ -357,12 +351,12 @@ function addNodeReferences(
                 if (baseSegment.localRefs && (baseSegment.localRefs.hierRefCount !== undefined) &&
                     (baseSegment.localRefs.hierRefCount > 0)) {
                     for (const lref of baseSegment.localRefs) {
-                        if (lref.refType & ReferenceType.Tile) {
+                        if (refTypeIncludesFlag(lref, ReferenceType.Tile)) {
                             addTile(lref, rightmostTiles);
                             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 +616,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,42 +688,55 @@ 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);
     }
 
     toString() {
         let bbuf = "";
-        if (this.refType & ReferenceType.Tile) {
+        if (refTypeIncludesFlag(this, ReferenceType.Tile)) {
             bbuf += "Tile";
         }
-        if (this.refType & ReferenceType.NestBegin) {
+        if (refTypeIncludesFlag(this, ReferenceType.NestBegin)) {
             if (bbuf.length > 0) {
                 bbuf += "; ";
             }
             bbuf += "RangeBegin";
         }
-        if (this.refType & ReferenceType.NestEnd) {
+        if (refTypeIncludesFlag(this, ReferenceType.NestEnd)) {
             if (bbuf.length > 0) {
                 bbuf += "; ";
             }
@@ -774,7 +747,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,10 +758,10 @@ 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) {
+            if (refTypeIncludesFlag(this, ReferenceType.NestEnd)) {
                 rangeKind = "end";
             }
             if (tileLabels) {
@@ -931,7 +904,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 +954,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 +967,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 +1107,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 +1175,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 +1198,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 +1438,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 +1462,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 +1684,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 +1851,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 +1917,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 +1978,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 +2047,7 @@ export class MergeTree {
                 operation: MergeTreeMaintenanceType.SPLIT,
                 deltaSegments: [{ segment }, { segment: next }],
             },
-            undefined);
+                undefined);
         }
 
         return { next };
@@ -2178,7 +2155,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 +2444,34 @@ export class MergeTree {
         }
     }
 
+    public removeLocalReferencePosition(lref: ReferencePosition): ReferencePosition | undefined {
+        const segment = lref.getSegment();
+        if (segment) {
+            const removedRefs = segment?.localRefs?.removeLocalRef(lref);
+            if (removedRefs !== undefined) {
+                this.blockUpdatePathLengths(segment.parent, TreeMaintenanceSequenceNumber,
+                    LocalClientId);
+            }
+            return removedRefs;
+        }
+    }
+    public createLocalReferencePosition(
+        segment: ISegment, offset: number, refType: ReferenceType, properties: PropertySet | undefined,
+        client: Client,
+    ): ReferencePosition {
+        const localRefs = segment.localRefs ?? new LocalReferenceCollection(segment);
+        segment.localRefs = localRefs;
+
+        const segRef = localRefs.createLocalRef(offset, refType, properties, client);
+
+        this.blockUpdatePathLengths(segment.parent, TreeMaintenanceSequenceNumber,
+            LocalClientId);
+        return segRef;
+    }
+
+    /**
+     * @deprecated - use removeLocalReferencePosition
+     */
     public removeLocalReference(segment: ISegment, lref: LocalReference) {
         if (segment.localRefs) {
             const removedRef = segment.localRefs.removeLocalRef(lref);
@@ -2477,6 +2482,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,126 @@
+/*!
+ * 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 function refTypeIncludesFlag(refPos: ReferencePosition, flags: ReferenceType): boolean {
+    // eslint-disable-next-line no-bitwise
+    return (refPos.refType & flags) !== 0;
+}
+
+export const refGetTileLabels = (refPos: ReferencePosition): string[] | undefined =>
+    refTypeIncludesFlag(refPos, ReferenceType.Tile)
+        && refPos.properties ? refPos.properties[reservedTileLabelsKey] as string[] : undefined;
+
+export const refGetRangeLabels = (refPos: ReferencePosition): string[] | undefined =>
+    // eslint-disable-next-line no-bitwise
+    (refTypeIncludesFlag(refPos, 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));
@@ -157,7 +157,7 @@ export class SnapshotLegacy {
                 if ((segment.seq !== UnassignedSequenceNumber) && (segment.seq! <= this.seq!) &&
                     ((segment.removedSeq === undefined) || (segment.removedSeq === UnassignedSequenceNumber) ||
                         (segment.removedSeq > this.seq!))) {
-                    if (prev && prev.canAppend(segment)
+                    if (prev?.canAppend(segment)
                         && matchProperties(prev.properties, segment.properties)
                     ) {
                         prev = prev.clone();