@fluidframework/merge-tree 0.58.0-55561 → 0.58.0-55983

package/src/partialLengths.ts

@@ -177,8 +177,8 @@ export class PartialSequenceLengths {
                     // Find next earliest sequence number
                     if (indices[k] < childPartialsCounts[k]) {
                         const cpLen = childPartials[k].partialLengths[indices[k]];
-                        // eslint-disable-next-line max-len
-                        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion, @typescript-eslint/no-unnecessary-type-assertion
+
+                        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                         if ((outerIndexOfEarliest < 0) || (cpLen.seq < earliestPartialLength!.seq)) {
                             outerIndexOfEarliest = k;
                             earliestPartialLength = cpLen;
@@ -186,8 +186,8 @@ export class PartialSequenceLengths {
                     }
                 }
                 if (outerIndexOfEarliest >= 0) {
-                    // eslint-disable-next-line max-len
-                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion, @typescript-eslint/no-unnecessary-type-assertion
+
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                     addNext(earliestPartialLength!);
                     indices[outerIndexOfEarliest]++;
                 }
@@ -263,9 +263,9 @@ export class PartialSequenceLengths {
         }
     }
 
-    private static getOverlapClients(overlapClientids: number[], seglen: number) {
+    private static getOverlapClients(overlapClientIds: number[], seglen: number) {
         const bst = new RedBlackTree<number, IOverlapClient>(compareNumbers);
-        for (const clientId of overlapClientids) {
+        for (const clientId of overlapClientIds) {
             bst.put(clientId, { clientId, seglen });
         }
         return bst;
@@ -277,11 +277,11 @@ export class PartialSequenceLengths {
         seglen: number) {
         if (partialLength.overlapRemoveClients) {
             for (const clientId of overlapRemoveClientIds) {
-                const ovlapClientNode = partialLength.overlapRemoveClients.get(clientId);
-                if (!ovlapClientNode) {
+                const overlapClientNode = partialLength.overlapRemoveClients.get(clientId);
+                if (!overlapClientNode) {
                     partialLength.overlapRemoveClients.put(clientId, { clientId, seglen });
                 } else {
-                    ovlapClientNode.data.seglen += seglen;
+                    overlapClientNode.data.seglen += seglen;
                 }
             }
         } else {
@@ -367,7 +367,7 @@ export class PartialSequenceLengths {
             }
         }
         if (seqPartialLen === undefined) {
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+
             seqPartialLen = {
                 clientId,
                 seglen: seqSeglen,
@@ -453,14 +453,14 @@ export class PartialSequenceLengths {
     public getPartialLength(refSeq: number, clientId: number) {
         let pLen = this.minLength;
         const seqIndex = latestLEQ(this.partialLengths, refSeq);
-        const cliLatestindex = this.cliLatest(clientId);
+        const cliLatestIndex = this.cliLatest(clientId);
         const cliSeq = this.clientSeqNumbers[clientId];
         if (seqIndex >= 0) {
             // Add the partial length up to refSeq
             pLen += this.partialLengths[seqIndex].len;
 
-            if (cliLatestindex >= 0) {
-                const cliLatest = cliSeq[cliLatestindex];
+            if (cliLatestIndex >= 0) {
+                const cliLatest = cliSeq[cliLatestIndex];
 
                 if (cliLatest.seq > refSeq) {
                     // The client has local edits after refSeq, add in the length adjustments
@@ -474,8 +474,8 @@ export class PartialSequenceLengths {
         } else {
             // RefSeq is before any of the partial lengths
             // so just add in all local edits of that client (which should all be after the refSeq)
-            if (cliLatestindex >= 0) {
-                const cliLatest = cliSeq[cliLatestindex];
+            if (cliLatestIndex >= 0) {
+                const cliLatest = cliSeq[cliLatestIndex];
                 pLen += cliLatest.len;
             }
         }
@@ -488,7 +488,7 @@ export class PartialSequenceLengths {
             buf += `(${partial.seq},${partial.len}) `;
         }
 
-        // eslint-disable-next-line @typescript-eslint/no-for-in-array, no-restricted-syntax
+        // eslint-disable-next-line @typescript-eslint/no-for-in-array
         for (const clientId in this.clientSeqNumbers) {
             if (this.clientSeqNumbers[clientId].length > 0) {
                 buf += `Client `;
@@ -530,7 +530,7 @@ export class PartialSequenceLengths {
             return minLength;
         }
         this.minLength += copyDown(this.partialLengths);
-        // eslint-disable-next-line @typescript-eslint/no-for-in-array, guard-for-in, no-restricted-syntax
+        // eslint-disable-next-line @typescript-eslint/no-for-in-array, guard-for-in
         for (const clientId in this.clientSeqNumbers) {
             const cliPartials = this.clientSeqNumbers[clientId];
             if (cliPartials) {

package/src/segmentPropertiesManager.ts

@@ -33,7 +33,7 @@ export class PropertiesManager {
                     0x05c /* "Trying to update more annotate props than do exist!" */);
                 this.pendingKeyUpdateCount[key]--;
                 if (this.pendingKeyUpdateCount?.[key] === 0) {
-                    // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+
                     delete this.pendingKeyUpdateCount[key];
                 }
             }
@@ -72,12 +72,12 @@ export class PropertiesManager {
             if (collaborating && seq === UnassignedSequenceNumber) {
                 this.pendingRewriteCount++;
             }
-            // We are re-writting so delete all the properties
+            // We are re-writing so delete all the properties
             // not in the new props
             for (const key of Object.keys(oldProps)) {
                 if (!newProps[key] && shouldModifyKey(key)) {
                     deltas[key] = oldProps[key];
-                    // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+
                     delete oldProps[key];
                 }
             }
@@ -105,7 +105,7 @@ export class PropertiesManager {
                 newValue = newProps[key];
             }
             if (newValue === null) {
-                // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+
                 delete oldProps[key];
             } else {
                 oldProps[key] = newValue;
@@ -122,7 +122,7 @@ export class PropertiesManager {
     ): PropertySet | undefined {
         if (oldProps) {
             if (!newProps) {
-                // eslint-disable-next-line no-param-reassign
+
                 newProps = createMap<any>();
             }
             if (!newManager) {

package/src/snapshotChunks.ts

@@ -94,7 +94,7 @@ export function serializeAsMinSupportedVersion(
     switch (chunk.version) {
         case undefined:
             targetChuck = chunk as MergeTreeChunkLegacy;
-            targetChuck.headerMetadata = buildHeaderMetadataForLegecyChunk(path, targetChuck, options);
+            targetChuck.headerMetadata = buildHeaderMetadataForLegacyChunk(path, targetChuck, options);
             break;
 
         case "1":
@@ -143,7 +143,7 @@ export function toLatestVersion(
                 version: "1",
                 length: chunkLegacy.chunkLengthChars,
                 segmentCount: chunkLegacy.chunkSegmentCount,
-                headerMetadata: buildHeaderMetadataForLegecyChunk(path, chunkLegacy, options),
+                headerMetadata: buildHeaderMetadataForLegacyChunk(path, chunkLegacy, options),
                 segments: chunkLegacy.segmentTexts,
                 startIndex: chunkLegacy.chunkStartSegmentIndex,
             };
@@ -156,7 +156,7 @@ export function toLatestVersion(
     }
 }
 
-function buildHeaderMetadataForLegecyChunk(
+function buildHeaderMetadataForLegacyChunk(
     path: string, chunk: MergeTreeChunkLegacy, options: PropertySet | undefined): MergeTreeHeaderMetadata | undefined {
     if (path === SnapshotLegacy.header) {
         if (chunk.headerMetadata !== undefined) {

package/src/snapshotV1.ts

@@ -48,6 +48,7 @@ export class SnapshotV1 {
     constructor(
         public mergeTree: MergeTree,
         logger: ITelemetryLogger,
+        private readonly getLongClientId: (id: number) => string,
         public filename?: string,
         public onCompletion?: () => void,
     ) {
@@ -209,8 +210,7 @@ export class SnapshotV1 {
                 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 if (segment.seq! > minSeq) {
                     raw.seq = segment.seq;
-                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                    raw.client = mergeTree.getLongClientId!(segment.clientId);
+                    raw.client = this.getLongClientId(segment.clientId);
                 }
                 // We have already dispensed with removed segments below the MSN and removed segments with unassigned
                 // sequence numbers.  Any remaining removal info should be preserved.
@@ -219,7 +219,7 @@ export class SnapshotV1 {
                         0x065 /* "On removal info preservation, segment has invalid removed sequence number!" */);
                     raw.removedSeq = segment.removedSeq;
                     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                    raw.removedClient = mergeTree.getLongClientId!(segment.removedClientId!);
+                    raw.removedClient = this.getLongClientId(segment.removedClientId!);
                 }
 
             // Sanity check that we are preserving either the seq < minSeq or a removed segment's info.

package/src/sortedSegmentSet.ts

@@ -10,37 +10,37 @@ import { ISegment } from "./mergeTree";
  *
  * This differs from a normal sorted set in that the keys are not fixed.
  * The segments are sorted via their ordinals which can change as the merge tree is modified.
- * Eventhough the values of the ordinals can change their ordering and uniqueness cannot, so the order of a set of
+ * Even though the values of the ordinals can change their ordering and uniqueness cannot, so the order of a set of
  * segments ordered by their ordinals will always have the same order even if the ordinal values on
- * the segments changes. This invarient allows ensure the segments stay ordered and unique, and that new segments
+ * 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> {
-    private readonly oridinalSortedItems: T[] = [];
+    private readonly ordinalSortedItems: T[] = [];
 
     public get size(): number {
-        return this.oridinalSortedItems.length;
+        return this.ordinalSortedItems.length;
     }
 
     public get items(): readonly T[] {
-        return this.oridinalSortedItems;
+        return this.ordinalSortedItems;
     }
 
     public addOrUpdate(newItem: T, update?: (existingItem: T, newItem: T) => T) {
         const position = this.findOrdinalPosition(this.getOrdinal(newItem));
         if (position.exists) {
             if (update) {
-                update(this.oridinalSortedItems[position.index], newItem);
+                update(this.ordinalSortedItems[position.index], newItem);
             }
         } else {
-            this.oridinalSortedItems.splice(position.index, 0, newItem);
+            this.ordinalSortedItems.splice(position.index, 0, newItem);
         }
     }
 
     public remove(item: T): boolean {
         const position = this.findOrdinalPosition(this.getOrdinal(item));
         if (position.exists) {
-            this.oridinalSortedItems.splice(position.index, 1);
+            this.ordinalSortedItems.splice(position.index, 1);
             return true;
         }
         return false;
@@ -62,19 +62,19 @@ export class SortedSegmentSet<T extends ISegment | { readonly segment: ISegment
     }
 
     private findOrdinalPosition(ordinal: string, start?: number, end?: number): { exists: boolean, index: number } {
-        if (this.oridinalSortedItems.length === 0) {
+        if (this.ordinalSortedItems.length === 0) {
             return { exists: false, index: 0 };
         }
         if (start === undefined || end === undefined) {
-            return this.findOrdinalPosition(ordinal, 0, this.oridinalSortedItems.length - 1);
+            return this.findOrdinalPosition(ordinal, 0, this.ordinalSortedItems.length - 1);
         }
         const index = start + Math.floor((end - start) / 2);
-        if (this.getOrdinal(this.oridinalSortedItems[index]) > ordinal) {
+        if (this.getOrdinal(this.ordinalSortedItems[index]) > ordinal) {
             if (start === index) {
                 return { exists: false, index };
             }
             return this.findOrdinalPosition(ordinal, start, index - 1);
-        } else if (this.getOrdinal(this.oridinalSortedItems[index]) < ordinal) {
+        } else if (this.getOrdinal(this.ordinalSortedItems[index]) < ordinal) {
             if (index === end) {
                 return { exists: false, index: index + 1 };
             }

package/src/textSegment.ts

@@ -31,11 +31,11 @@ export class TextSegment extends BaseSegment {
     }
 
     public static make(text: string, props?: PropertySet) {
-        const tseg = new TextSegment(text);
+        const seg = new TextSegment(text);
         if (props) {
-            tseg.addProperties(props);
+            seg.addProperties(props);
         }
-        return tseg;
+        return seg;
     }
 
     public static fromJSONObject(spec: any) {