@fluidframework/merge-tree 0.59.3000-66610 → 0.59.3000-67119

package/src/localReference.ts

@@ -5,12 +5,14 @@
 
 import { assert } from "@fluidframework/common-utils";
 import { Client } from "./client";
+import { List, ListMakeHead, ListRemoveEntry } from "./collections";
 import {
     ISegment,
 } from "./mergeTree";
 import { ICombiningOp, ReferenceType } from "./ops";
 import { addProperties, PropertySet } from "./properties";
-import { minReferencePosition,
+import {
+    minReferencePosition,
     maxReferencePosition,
     compareReferencePositions,
     refHasTileLabels,
@@ -20,12 +22,13 @@ import { minReferencePosition,
     refGetTileLabels,
     refHasRangeLabel,
     refHasTileLabel,
+    refTypeIncludesFlag,
 } from "./referencePositions";
 
 /**
  * @deprecated - Use ReferencePosition
  */
- export class LocalReference implements ReferencePosition {
+export class LocalReference implements ReferencePosition {
     /**
      * @deprecated - use DetachedReferencePosition
      */
@@ -50,7 +53,7 @@ import { minReferencePosition,
         /**
          * @deprecated - use getOffset
          */
-        public offset = 0,
+        public offset: number = 0,
         public refType = ReferenceType.Simple,
         properties?: PropertySet,
     ) {
@@ -81,23 +84,19 @@ import { minReferencePosition,
      * @deprecated - use getLocalReferencePosition
      */
     public toPosition() {
-        if (this.segment && this.segment.parent) {
-            return this.getOffset() + this.client.getPosition(this.segment);
-        } else {
-            return LocalReference.DetachedPosition;
-        }
+        return this.getClient().localReferencePositionToPosition(this);
     }
 
     /**
      * @deprecated - use refHasTileLabels
      */
-    public hasTileLabels() {
+    public hasTileLabels(): boolean {
         return refHasTileLabels(this);
     }
     /**
      * @deprecated - use refHasRangeLabels
      */
-    public hasRangeLabels() {
+    public hasRangeLabels(): boolean {
         return refHasRangeLabels(this);
     }
     /**
@@ -157,13 +156,17 @@ import { minReferencePosition,
 }
 
 interface IRefsAtOffset {
-    before?: LocalReference[];
-    at?: LocalReference[];
-    after?: LocalReference[];
+    before?: List<LocalReference>;
+    at?: List<LocalReference>;
+    after?: List<LocalReference>;
+}
+
+function assertLocalReferences(lref: ReferencePosition | LocalReference): asserts lref is LocalReference {
+    assert(lref instanceof LocalReference, 0x2e0 /* "lref not a Local Reference" */);
 }
 
 /**
- * Represents a collection of {@link LocalReference}s associated with one segment in a merge-tree.
+ * Represents a collection of {@link ReferencePosition}s associated with one segment in a merge-tree.
  */
 export class LocalReferenceCollection {
     public static append(seg1: ISegment, seg2: ISegment) {
@@ -181,10 +184,18 @@ export class LocalReferenceCollection {
         }
     }
 
+    /**
+     *
+     * @internal - this method should only be called by mergeTree
+     */
     public hierRefCount: number = 0;
     private readonly refsByOffset: (IRefsAtOffset | undefined)[];
     private refCount: number = 0;
 
+    /**
+     *
+     * @internal - this method should only be called by mergeTree
+     */
     constructor(
         /** Segment this `LocalReferenceCollection` is associated to. */
         private readonly segment: ISegment,
@@ -195,6 +206,10 @@ export class LocalReferenceCollection {
         this.refsByOffset = initialRefsByfOffset;
     }
 
+    /**
+     *
+     * @internal - this method should only be called by mergeTree
+     */
     public [Symbol.iterator]() {
         const subiterators: IterableIterator<LocalReference>[] = [];
         for (const refs of this.refsByOffset) {
@@ -231,16 +246,20 @@ export class LocalReferenceCollection {
         return iterator;
     }
 
+    /**
+     *
+     * @internal - this method should only be called by mergeTree
+     */
     public clear() {
         this.refCount = 0;
         this.hierRefCount = 0;
-        const detachSegments = (refs: LocalReference[] | undefined) => {
+        const detachSegments = (refs: List<LocalReference> | undefined) => {
             if (refs) {
-                refs.forEach((r) => {
+                for (const r of refs) {
                     if (r.segment === this.segment) {
                         r.segment = undefined;
                     }
-                });
+                }
             }
         };
         for (let i = 0; i < this.refsByOffset.length; i++) {
@@ -254,41 +273,80 @@ export class LocalReferenceCollection {
         }
     }
 
+    /**
+     *
+     * @internal - this method should only be called by mergeTree
+     */
     public get empty() {
         return this.refCount === 0;
     }
 
-    public addLocalRef(lref: LocalReference) {
-        const refsAtOffset = this.refsByOffset[lref.offset];
-        if (refsAtOffset === undefined) {
-            this.refsByOffset[lref.offset] = {
-                at: [lref],
-            };
-        } else if (refsAtOffset.at === undefined) {
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            this.refsByOffset[lref.offset]!.at = [lref];
-        } else {
-            refsAtOffset.at.push(lref);
+    /**
+     *
+     * @internal - this method should only be called by mergeTree
+     */
+    public createLocalRef(
+        offset: number,
+        refType: ReferenceType,
+        properties: PropertySet | undefined,
+        client: Client): ReferencePosition {
+        const ref = new LocalReference(
+            client,
+            this.segment,
+            offset,
+            refType,
+            properties,
+        );
+        if (!refTypeIncludesFlag(ref, ReferenceType.Transient)) {
+            this.addLocalRef(ref);
         }
+        return ref;
+    }
 
-        if (lref.hasRangeLabels() || lref.hasTileLabels()) {
+    /**
+     *
+     * @internal - this method should only be called by mergeTree
+     */
+    public addLocalRef(lref: LocalReference | ReferencePosition) {
+        assert(
+            !refTypeIncludesFlag(lref, ReferenceType.Transient),
+            0x2df /* "transient references cannot be bound to segments" */);
+        assertLocalReferences(lref);
+        const refsAtOffset = this.refsByOffset[lref.getOffset()] =
+            this.refsByOffset[lref.getOffset()]
+            ?? { at: ListMakeHead() };
+        const atRefs = refsAtOffset.at =
+            refsAtOffset.at
+            ?? ListMakeHead();
+
+        atRefs.enqueue(lref);
+
+        if (refHasRangeLabels(lref) || refHasTileLabels(lref)) {
             this.hierRefCount++;
         }
         this.refCount++;
     }
 
-    public removeLocalRef(lref: LocalReference) {
-        const tryRemoveRef = (refs: LocalReference[] | undefined) => {
+    /**
+     *
+     * @internal - this method should only be called by mergeTree
+     */
+    public removeLocalRef(lref: LocalReference | ReferencePosition) {
+        assertLocalReferences(lref);
+        const tryRemoveRef = (refs: List<LocalReference> | undefined) => {
             if (refs) {
-                const index = refs.indexOf(lref);
-                if (index >= 0) {
-                    refs.splice(index, 1);
-                    if (lref.hasRangeLabels() || lref.hasTileLabels()) {
-                        this.hierRefCount--;
+                let node = refs;
+                do {
+                    node = node.next;
+                    if (node.data === lref) {
+                        ListRemoveEntry(node);
+                        if (refHasRangeLabels(lref) || refHasTileLabels(lref)) {
+                            this.hierRefCount--;
+                        }
+                        this.refCount--;
+                        return lref;
                     }
-                    this.refCount--;
-                    return lref;
-                }
+                } while (!node.isHead);
             }
         };
         const refAtOffset = this.refsByOffset[lref.offset];
@@ -311,6 +369,8 @@ export class LocalReferenceCollection {
     }
 
     /**
+     * @internal - this method should only be called by mergeTree
+     *
      * Called by 'append()' implementations to append local refs from the given 'other' segment to the
      * end of 'this' segment.
      *
@@ -334,6 +394,8 @@ export class LocalReferenceCollection {
     }
 
     /**
+     * @internal - this method should only be called by mergeTree
+     *
      * Splits this `LocalReferenceCollection` into the intervals [0, offset) and [offset, originalLength).
      * Local references in the former half of this split will remain associated with the segment used on construction.
      * Local references in the latter half of this split will be transferred to `splitSeg`,
@@ -353,7 +415,7 @@ export class LocalReferenceCollection {
             for (const lref of localRefs) {
                 lref.segment = splitSeg;
                 lref.offset -= offset;
-                if (lref.hasRangeLabels() || lref.hasTileLabels()) {
+                if (refHasRangeLabels(lref) || refHasTileLabels(lref)) {
                     this.hierRefCount--;
                     localRefs.hierRefCount++;
                 }
@@ -366,17 +428,17 @@ export class LocalReferenceCollection {
         }
     }
 
-    public addBeforeTombstones(...refs: Iterable<LocalReference>[]) {
-        const beforeRefs: LocalReference[] = [];
+    public addBeforeTombstones(...refs: Iterable<LocalReference | ReferencePosition>[]) {
+        const beforeRefs = this.refsByOffset[0]?.before ?? ListMakeHead();
 
         for (const iterable of refs) {
             for (const lref of iterable) {
-                // eslint-disable-next-line no-bitwise
-                if (lref.refType & ReferenceType.SlideOnRemove) {
+                assertLocalReferences(lref);
+                if (refTypeIncludesFlag(lref, ReferenceType.SlideOnRemove)) {
                     beforeRefs.push(lref);
                     lref.segment = this.segment;
                     lref.offset = 0;
-                    if (lref.hasRangeLabels() || lref.hasTileLabels()) {
+                    if (refHasRangeLabels(lref) || refHasTileLabels(lref)) {
                         this.hierRefCount++;
                     }
                     this.refCount++;
@@ -385,28 +447,27 @@ export class LocalReferenceCollection {
                 }
             }
         }
-        if (beforeRefs.length > 0) {
-            if (this.refsByOffset[0] === undefined) {
-                this.refsByOffset[0] = { before: beforeRefs };
-            } else if (this.refsByOffset[0].before === undefined) {
-                this.refsByOffset[0].before = beforeRefs;
-            } else {
-                this.refsByOffset[0].before.unshift(...beforeRefs);
-            }
+        if (!beforeRefs.empty() && this.refsByOffset[0]?.before === undefined) {
+            const refsAtOffset = this.refsByOffset[0] =
+                this.refsByOffset[0]
+                ?? { before: beforeRefs };
+            refsAtOffset.before = refsAtOffset.before ?? beforeRefs;
         }
     }
 
-    public addAfterTombstones(...refs: Iterable<LocalReference>[]) {
-        const afterRefs: LocalReference[] = [];
+    public addAfterTombstones(...refs: Iterable<LocalReference | ReferencePosition>[]) {
+        const lastOffset = this.refsByOffset.length - 1;
+        const afterRefs =
+            this.refsByOffset[lastOffset]?.after ?? ListMakeHead();
 
         for (const iterable of refs) {
             for (const lref of iterable) {
-                // eslint-disable-next-line no-bitwise
-                if (lref.refType & ReferenceType.SlideOnRemove) {
+                assertLocalReferences(lref);
+                if (refTypeIncludesFlag(lref, ReferenceType.SlideOnRemove)) {
                     afterRefs.push(lref);
                     lref.segment = this.segment;
                     lref.offset = this.segment.cachedLength - 1;
-                    if (lref.hasRangeLabels() || lref.hasTileLabels()) {
+                    if (refHasRangeLabels(lref) || refHasTileLabels(lref)) {
                         this.hierRefCount++;
                     }
                     this.refCount++;
@@ -415,15 +476,11 @@ export class LocalReferenceCollection {
                 }
             }
         }
-        if (afterRefs.length > 0) {
-            const refsAtOffset = this.refsByOffset[this.segment.cachedLength - 1];
-            if (refsAtOffset === undefined) {
-                this.refsByOffset[this.segment.cachedLength - 1] = { after: afterRefs };
-            } else if (refsAtOffset.after === undefined) {
-                refsAtOffset.after = afterRefs;
-            } else {
-                refsAtOffset.after.push(...afterRefs);
-            }
+        if (!afterRefs.empty() && this.refsByOffset[lastOffset]?.after === undefined) {
+            const refsAtOffset = this.refsByOffset[lastOffset] =
+                this.refsByOffset[lastOffset]
+                ?? { after: afterRefs };
+            refsAtOffset.after = refsAtOffset.after ?? afterRefs;
         }
     }
 }

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 {
@@ -51,6 +51,7 @@ import {
     PropertySet,
 } from "./properties";
 import {
+    refTypeIncludesFlag,
     RangeStackMap,
     ReferencePosition,
     refGetRangeLabels,
@@ -62,6 +63,7 @@ import {
  } from "./referencePositions";
 import { SegmentGroupCollection } from "./segmentGroupCollection";
 import { PropertiesManager } from "./segmentPropertiesManager";
+import { Client } from "./client";
 
 export interface IMergeNodeCommon {
     parent?: IMergeBlock;
@@ -294,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);
@@ -332,7 +334,7 @@ function addNodeReferences(
                 if (markerId) {
                     mergeTree.mapIdToSegment(markerId, segment);
                 }
-                if (segment.refType & ReferenceType.Tile) {
+                if (refTypeIncludesFlag(segment, ReferenceType.Tile)) {
                     addTile(segment, rightmostTiles);
                     addTileIfNotPresent(segment, leftmostTiles);
                 }
@@ -349,7 +351,7 @@ 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);
                         }
@@ -725,16 +727,16 @@ export class Marker extends BaseSegment implements ReferencePosition {
 
     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 += "; ";
             }
@@ -759,7 +761,7 @@ export class Marker extends BaseSegment implements ReferencePosition {
         const rangeLabels = refGetRangeLabels(this);
         if (rangeLabels) {
             let rangeKind = "begin";
-            if (this.refType & ReferenceType.NestEnd) {
+            if (refTypeIncludesFlag(this, ReferenceType.NestEnd)) {
                 rangeKind = "end";
             }
             if (tileLabels) {
@@ -2442,6 +2444,31 @@ 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
      */

package/src/referencePositions.ts

@@ -11,14 +11,18 @@ import { PropertySet, MapLike } from "./properties";
 export const reservedTileLabelsKey = "referenceTileLabels";
 export const reservedRangeLabelsKey = "referenceRangeLabels";
 
-export const refGetTileLabels = (refPos: ReferencePosition): string[] | undefined =>
+export function refTypeIncludesFlag(refPos: ReferencePosition, flags: ReferenceType): boolean {
     // eslint-disable-next-line no-bitwise
-    (refPos.refType & ReferenceType.Tile)
+    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
-    (refPos.refType & (ReferenceType.NestBegin | ReferenceType.NestEnd))
+    (refTypeIncludesFlag(refPos, ReferenceType.NestBegin | ReferenceType.NestEnd))
         && refPos.properties ? refPos.properties[reservedRangeLabelsKey] as string[] : undefined;
 
 export function refHasTileLabel(refPos: ReferencePosition, label: string): boolean {

package/src/snapshotlegacy.ts

@@ -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();

package/src/sortedSegmentSet.ts

@@ -53,7 +53,7 @@ export class SortedSegmentSet<T extends ISegment | { readonly segment: ISegment;
 
     private getOrdinal(item: T): string {
         const maybeObject = item as { readonly segment: ISegment; };
-        if (maybeObject && maybeObject.segment) {
+        if (maybeObject?.segment) {
             return maybeObject.segment.ordinal;
         }
 

package/src/textSegment.ts

@@ -204,10 +204,10 @@ export class MergeTreeTextHelper {
                 const tags = [] as string[];
                 const initTags = [] as string[];
 
-                if (segment.properties && (segment.properties["font-weight"])) {
+                if (segment.properties?.["font-weight"]) {
                     tags.push("b");
                 }
-                if (segment.properties && (segment.properties["text-decoration"])) {
+                if (segment.properties?.["text-decoration"]) {
                     tags.push("u");
                 }
                 const remTags = [] as string[];