@fluidframework/merge-tree 2.0.0-internal.4.0.5 → 2.0.0-internal.4.1.0

package/CHANGELOG.md

@@ -0,0 +1,5 @@
+# @fluidframework/merge-tree
+
+## 2.0.0-internal.4.1.0
+
+Dependency updates only.

package/README.md

@@ -5,6 +5,26 @@ sequence of collaboratively edited items. MergeTree is used in both SharedSequen
 
 See [GitHub](https://github.com/microsoft/FluidFramework) for more details on the Fluid Framework and packages within.
 
+<!-- AUTO-GENERATED-CONTENT:START (README_DEPENDENCY_GUIDELINES_SECTION:includeHeading=TRUE) -->
+
+<!-- prettier-ignore-start -->
+<!-- NOTE: This section is automatically generated using @fluid-tools/markdown-magic. Do not update these generated contents directly. -->
+
+## Using Fluid Framework libraries
+
+When taking a dependency on a Fluid Framework library, we recommend using a `^` (caret) version range, such as `^1.3.4`.
+While Fluid Framework libraries may use different ranges with interdependencies between other Fluid Framework libraries,
+library consumers should always prefer `^`.
+
+Note that when depending on a library version of the form 2.0.0-internal.x.y.z, called the Fluid internal version
+scheme, you must use a `>= <` dependency range. Standard `^` and `~` ranges will not work as expected. See the
+[@fluid-tools/version-tools](https://github.com/microsoft/FluidFramework/blob/main/build-tools/packages/version-tools/README.md)
+package for more information including tools to convert between version schemes.
+
+<!-- prettier-ignore-end -->
+
+<!-- AUTO-GENERATED-CONTENT:END -->
+
 ## Operations
 
 The three basic operations provided by MergeTree are:

package/dist/attributionCollection.d.ts

@@ -3,20 +3,46 @@
  * Licensed under the MIT License.
  */
 import { AttributionKey } from "@fluidframework/runtime-definitions";
-import { AttributionPolicy } from "./mergeTree";
 import { ISegment } from "./mergeTreeNodes";
 /**
  * @internal
  */
-export interface SerializedAttributionCollection {
+export interface SequenceOffsets {
     /**
      * Parallel array with posBreakpoints which tracks the seq of insertion.
      * Ex: if seqs is [45, 46] and posBreakpoints is [0, 3], the section of the string
      * between offsets 0 and 3 was inserted at seq 45 and the section of the string between
      * 3 and the length of the string was inserted at seq 46.
+     *
+     * @remarks - We use null here rather than undefined as round-tripping through JSON converts
+     * undefineds to null anyway
      */
-    seqs: (number | AttributionKey)[];
+    seqs: (number | AttributionKey | null)[];
     posBreakpoints: number[];
+}
+/**
+ * @internal
+ */
+export interface SerializedAttributionCollection extends SequenceOffsets {
+    channels?: {
+        [name: string]: SequenceOffsets;
+    };
+    length: number;
+}
+/**
+ * @internal
+ */
+export interface IAttributionCollectionSpec<T> {
+    root: Iterable<{
+        offset: number;
+        key: T | null;
+    }>;
+    channels?: {
+        [name: string]: Iterable<{
+            offset: number;
+            key: T | null;
+        }>;
+    };
     length: number;
 }
 /**
@@ -43,12 +69,14 @@ export interface IAttributionCollectionSerializer {
 export interface IAttributionCollection<T> {
     /**
      * Retrieves the attribution key associated with the provided offset.
+     * @param channel - When specified, gets an attribution key associated with a particular channel.
      */
-    getAtOffset(offset: number): T;
+    getAtOffset(offset: number, channel?: string): AttributionKey | undefined;
     /**
      * Total length of all attribution keys in this collection.
      */
     readonly length: number;
+    readonly channelNames: Iterable<string>;
     /**
      * Retrieve all key/offset pairs stored on this segment. Entries should be ordered by offset, such that
      * the `i`th result's attribution key applies to offsets in the open range between the `i`th offset and the
@@ -56,53 +84,58 @@ export interface IAttributionCollection<T> {
      * The last entry's key applies to the open interval from the last entry's offset to this collection's length.
      * @internal
      */
-    getAll(): Iterable<{
-        offset: number;
-        key: T;
-    }>;
+    getAll(): IAttributionCollectionSpec<T>;
     /** @internal */
     splitAt(pos: number): IAttributionCollection<T>;
     /** @internal */
     append(other: IAttributionCollection<T>): void;
     /** @internal */
     clone(): IAttributionCollection<T>;
+    /**
+     * Updates this collection with new attribution data.
+     * @param name - Name of the channel that requires an update. Undefined signifies the root channel.
+     * Updates apply only to the individual channel (i.e. if an attribution policy needs to update the root
+     * channel and 4 other channels, it should call `.update` 5 times).
+     * @param channel - Updated collection for that channel.
+     * @internal
+     */
+    update(name: string | undefined, channel: IAttributionCollection<T>): any;
 }
-export declare function areEqualAttributionKeys(a: AttributionKey, b: AttributionKey): boolean;
+export declare function areEqualAttributionKeys(a: AttributionKey | null | undefined, b: AttributionKey | null | undefined): boolean;
 export declare class AttributionCollection implements IAttributionCollection<AttributionKey> {
     private _length;
     private offsets;
     private keys;
-    constructor(baseEntry: AttributionKey, _length: number);
+    private channels?;
+    private get channelEntries();
+    constructor(_length: number, baseEntry?: AttributionKey | null);
+    get channelNames(): string[];
     getAtOffset(offset: number): AttributionKey;
+    getAtOffset(offset: number, channel: string): AttributionKey | undefined;
     private findIndex;
+    private get;
     get length(): number;
     /**
      * Splits this attribution collection into two with entries for [0, pos) and [pos, length).
      */
     splitAt(pos: number): AttributionCollection;
     append(other: AttributionCollection): void;
-    getAll(): {
-        offset: number;
-        key: AttributionKey;
-    }[];
+    getAll(): IAttributionCollectionSpec<AttributionKey>;
     clone(): AttributionCollection;
+    update(name: string | undefined, channel: AttributionCollection): void;
     /**
      * Rehydrates attribution information from its serialized form into the provided iterable of consecutive segments.
      */
-    static populateAttributionCollections(segments: Iterable<ISegment>, summary: SerializedAttributionCollection): void;
+    static populateAttributionCollections(segments: ISegment[], summary: SerializedAttributionCollection): void;
     /**
      * Condenses attribution information on consecutive segments into a `SerializedAttributionCollection`
+     *
+     * Note: this operates on segments rather than attribution collections directly so that it can handle cases
+     * where only some segments have attribution defined.
      */
     static serializeAttributionCollections(segments: Iterable<{
         attribution?: IAttributionCollection<AttributionKey>;
         cachedLength: number;
     }>): SerializedAttributionCollection;
 }
-/**
- * @alpha
- * @returns - An {@link AttributionPolicy} which tracks only insertion of content.
- * Content is only attributed at ack time, unless the container is in a detached state.
- * Detached content is attributed with a {@link @fluidframework/runtime-definitions#DetachedAttributionKey}.
- */
-export declare function createInsertOnlyAttributionPolicy(): AttributionPolicy;
 //# sourceMappingURL=attributionCollection.d.ts.map

package/dist/attributionCollection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"attributionCollection.d.ts","sourceRoot":"","sources":["../src/attributionCollection.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EACN,cAAc,EAGd,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAQhD,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAG5C;;GAEG;AACH,MAAM,WAAW,+BAA+B;IAC/C;;;;;OAKG;IACH,IAAI,EAAE,CAAC,MAAM,GAAG,cAAc,CAAC,EAAE,CAAC;IAClC,cAAc,EAAE,MAAM,EAAE,CAAC;IAEzB,MAAM,EAAE,MAAM,CAAC;CACf;AAED;;;GAGG;AACH,MAAM,WAAW,gCAAgC;IAChD;;OAEG;IACH,+BAA+B,CAC9B,QAAQ,EAAE,QAAQ,CAAC;QAClB,WAAW,CAAC,EAAE,sBAAsB,CAAC,cAAc,CAAC,CAAC;QACrD,YAAY,EAAE,MAAM,CAAC;KACrB,CAAC,GACA,+BAA+B,CAAC;IAEnC;;;OAGG;IACH,8BAA8B,CAC7B,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,EAC5B,OAAO,EAAE,+BAA+B,GACtC,IAAI,CAAC;CACR;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB,CAAC,CAAC;IACxC;;OAEG;IACH,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,CAAC,CAAC;IAE/B;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAExB;;;;;;OAMG;IACH,MAAM,IAAI,QAAQ,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,CAAC,CAAA;KAAE,CAAC,CAAC;IAE/C,gBAAgB;IAChB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,sBAAsB,CAAC,CAAC,CAAC,CAAC;IAEhD,gBAAgB;IAChB,MAAM,CAAC,KAAK,EAAE,sBAAsB,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAE/C,gBAAgB;IAChB,KAAK,IAAI,sBAAsB,CAAC,CAAC,CAAC,CAAC;CACnC;AAED,wBAAgB,uBAAuB,CAAC,CAAC,EAAE,cAAc,EAAE,CAAC,EAAE,cAAc,GAAG,OAAO,CAgBrF;AAED,qBAAa,qBAAsB,YAAW,sBAAsB,CAAC,cAAc,CAAC;IAIrC,OAAO,CAAC,OAAO;IAH7D,OAAO,CAAC,OAAO,CAAW;IAC1B,OAAO,CAAC,IAAI,CAAmB;gBAEZ,SAAS,EAAE,cAAc,EAAU,OAAO,EAAE,MAAM;IAK9D,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc;IAKlD,OAAO,CAAC,SAAS;IAWjB,IAAW,MAAM,IAAI,MAAM,CAE1B;IAED;;OAEG;IACI,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,qBAAqB;IAgB3C,MAAM,CAAC,KAAK,EAAE,qBAAqB,GAAG,IAAI;IAW1C,MAAM,IAAI;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,cAAc,CAAA;KAAE,EAAE;IAQnD,KAAK,IAAI,qBAAqB;IAOrC;;OAEG;WACW,8BAA8B,CAC3C,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,EAC5B,OAAO,EAAE,+BAA+B,GACtC,IAAI;IAsCP;;OAEG;WACW,+BAA+B,CAC5C,QAAQ,EAAE,QAAQ,CAAC;QAClB,WAAW,CAAC,EAAE,sBAAsB,CAAC,cAAc,CAAC,CAAC;QACrD,YAAY,EAAE,MAAM,CAAC;KACrB,CAAC,GACA,+BAA+B;CAwClC;AAED;;;;;GAKG;AACH,wBAAgB,iCAAiC,IAAI,iBAAiB,CAsErE"}
+{"version":3,"file":"attributionCollection.d.ts","sourceRoot":"","sources":["../src/attributionCollection.ts"],"names":[],"mappings":"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"}

package/dist/attributionCollection.js

@@ -4,12 +4,16 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createInsertOnlyAttributionPolicy = exports.AttributionCollection = exports.areEqualAttributionKeys = void 0;
+exports.AttributionCollection = exports.areEqualAttributionKeys = void 0;
 const common_utils_1 = require("@fluidframework/common-utils");
-const constants_1 = require("./constants");
-const mergeTreeDeltaCallback_1 = require("./mergeTreeDeltaCallback");
-const ops_1 = require("./ops");
+// note: treats null and undefined as equivalent
 function areEqualAttributionKeys(a, b) {
+    if (!a && !b) {
+        return true;
+    }
+    if (!a || !b) {
+        return false;
+    }
     if (a.type !== b.type) {
         return false;
     }
@@ -27,14 +31,31 @@ function areEqualAttributionKeys(a, b) {
 }
 exports.areEqualAttributionKeys = areEqualAttributionKeys;
 class AttributionCollection {
-    constructor(baseEntry, _length) {
+    constructor(_length, baseEntry) {
         this._length = _length;
-        this.offsets = [0];
-        this.keys = [baseEntry];
+        this.offsets = [];
+        this.keys = [];
+        if (baseEntry !== undefined) {
+            this.offsets.push(0);
+            this.keys.push(baseEntry);
+        }
+    }
+    get channelEntries() {
+        var _a;
+        return Object.entries((_a = this.channels) !== null && _a !== void 0 ? _a : {});
+    }
+    get channelNames() {
+        var _a;
+        return Object.keys((_a = this.channels) !== null && _a !== void 0 ? _a : {});
     }
-    getAtOffset(offset) {
+    getAtOffset(offset, channel) {
+        var _a;
+        if (channel !== undefined) {
+            const subCollection = (_a = this.channels) === null || _a === void 0 ? void 0 : _a[channel];
+            return subCollection === null || subCollection === void 0 ? void 0 : subCollection.getAtOffset(offset);
+        }
         (0, common_utils_1.assert)(offset >= 0 && offset < this._length, 0x443 /* Requested offset should be valid */);
-        return this.keys[this.findIndex(offset)];
+        return this.get(this.findIndex(offset));
     }
     findIndex(offset) {
         // Note: maximum length here is 256 for text segments. Perf testing shows that linear scan beats binary search
@@ -46,6 +67,10 @@ class AttributionCollection {
         }
         return this.offsets[i] === offset ? i : i - 1;
     }
+    get(index) {
+        const key = this.keys[index];
+        return key !== null ? key : undefined;
+    }
     get length() {
         return this._length;
     }
@@ -54,12 +79,17 @@ class AttributionCollection {
      */
     splitAt(pos) {
         const splitIndex = this.findIndex(pos);
-        const splitBaseEntry = this.keys[splitIndex];
-        const splitCollection = new AttributionCollection(splitBaseEntry, this.length - pos);
-        for (let i = splitIndex + 1; i < this.keys.length; i++) {
-            splitCollection.offsets.push(this.offsets[i] - pos);
+        const splitCollection = new AttributionCollection(this.length - pos);
+        for (let i = splitIndex; i < this.keys.length; i++) {
+            splitCollection.offsets.push(Math.max(this.offsets[i] - pos, 0));
             splitCollection.keys.push(this.keys[i]);
         }
+        if (this.channels) {
+            splitCollection.channels = {};
+            for (const [key, collection] of this.channelEntries) {
+                splitCollection.channels[key] = collection.splitAt(pos);
+            }
+        }
         const spliceIndex = this.offsets[splitIndex] === pos ? splitIndex : splitIndex + 1;
         this.keys.splice(spliceIndex);
         this.offsets.splice(spliceIndex);
@@ -67,6 +97,8 @@ class AttributionCollection {
         return splitCollection;
     }
     append(other) {
+        var _a, _b, _c;
+        var _d;
         const lastEntry = this.keys[this.keys.length - 1];
         for (let i = 0; i < other.keys.length; i++) {
             if (i !== 0 || !areEqualAttributionKeys(lastEntry, other.keys[i])) {
@@ -74,140 +106,162 @@ class AttributionCollection {
                 this.keys.push(other.keys[i]);
             }
         }
+        if (other.channels !== undefined || this.channels !== undefined) {
+            (_a = this.channels) !== null && _a !== void 0 ? _a : (this.channels = {});
+            for (const [key, collection] of other.channelEntries) {
+                const thisCollection = ((_b = (_d = this.channels)[key]) !== null && _b !== void 0 ? _b : (_d[key] = new AttributionCollection(this.length, null)));
+                thisCollection.append(collection);
+            }
+            for (const [key, collection] of this.channelEntries) {
+                if (((_c = other.channels) === null || _c === void 0 ? void 0 : _c[key]) === undefined) {
+                    collection.append(new AttributionCollection(other.length, null));
+                }
+            }
+        }
         this._length += other.length;
     }
     getAll() {
-        const results = new Array(this.keys.length);
+        const root = new Array(this.keys.length);
         for (let i = 0; i < this.keys.length; i++) {
-            results[i] = { offset: this.offsets[i], key: this.keys[i] };
+            root[i] = { offset: this.offsets[i], key: this.keys[i] };
+        }
+        const result = {
+            root,
+            length: this.length,
+        };
+        if (this.channels !== undefined) {
+            result.channels = {};
+            for (const [key, collection] of this.channelEntries) {
+                result.channels[key] = collection.getAll().root;
+            }
         }
-        return results;
+        return result;
     }
     clone() {
-        const copy = new AttributionCollection(this.keys[0], this.length);
+        const copy = new AttributionCollection(this.length);
         copy.keys = this.keys.slice();
         copy.offsets = this.offsets.slice();
+        if (this.channels !== undefined) {
+            const channelsCopy = {};
+            for (const [key, collection] of this.channelEntries) {
+                channelsCopy[key] = collection.clone();
+            }
+            copy.channels = channelsCopy;
+        }
         return copy;
     }
+    update(name, channel) {
+        var _a;
+        (0, common_utils_1.assert)(channel.length === this.length, 0x5c0 /* AttributionCollection channel update should have consistent segment length */);
+        if (name === undefined) {
+            this.offsets = [...channel.offsets];
+            this.keys = [...channel.keys];
+        }
+        else {
+            (_a = this.channels) !== null && _a !== void 0 ? _a : (this.channels = {});
+            if (this.channels[name] !== undefined) {
+                this.channels[name].update(undefined, channel);
+            }
+            else {
+                this.channels[name] = channel;
+            }
+        }
+    }
     /**
      * Rehydrates attribution information from its serialized form into the provided iterable of consecutive segments.
      */
     static populateAttributionCollections(segments, summary) {
-        const { seqs, posBreakpoints } = summary;
-        (0, common_utils_1.assert)(seqs.length === posBreakpoints.length && seqs.length > 0, 0x445 /* Invalid attribution summary blob provided */);
-        let curIndex = 0;
-        let currentInfo = seqs[curIndex];
-        let cumulativeSegPos = 0;
-        for (const segment of segments) {
-            const attribution = new AttributionCollection(typeof currentInfo === "object" ? currentInfo : { type: "op", seq: currentInfo }, segment.cachedLength);
-            while (posBreakpoints[curIndex] < cumulativeSegPos + segment.cachedLength) {
-                currentInfo = seqs[curIndex];
-                const nextOffset = posBreakpoints[curIndex] - cumulativeSegPos;
-                if (attribution.offsets[attribution.offsets.length - 1] !== nextOffset) {
-                    attribution.offsets.push(nextOffset);
-                    attribution.keys.push(typeof currentInfo === "object"
-                        ? currentInfo
-                        : { type: "op", seq: currentInfo });
+        const { channels } = summary;
+        (0, common_utils_1.assert)(summary.seqs.length === summary.posBreakpoints.length, 0x445 /* Invalid attribution summary blob provided */);
+        const extractOntoSegments = ({ seqs, posBreakpoints }, assignToSegment) => {
+            let curIndex = 0;
+            let cumulativeSegPos = 0;
+            for (const segment of segments) {
+                const attribution = new AttributionCollection(segment.cachedLength);
+                const pushEntry = (offset, seq) => {
+                    attribution.offsets.push(offset);
+                    attribution.keys.push(seq === null ? null : typeof seq === "object" ? seq : { type: "op", seq });
+                };
+                if (posBreakpoints[curIndex] > cumulativeSegPos) {
+                    curIndex--;
+                }
+                while (posBreakpoints[curIndex] < cumulativeSegPos + segment.cachedLength) {
+                    const nextOffset = Math.max(posBreakpoints[curIndex] - cumulativeSegPos, 0);
+                    pushEntry(nextOffset, seqs[curIndex]);
+                    curIndex++;
                 }
-                curIndex++;
+                if (attribution.offsets.length === 0) {
+                    pushEntry(0, seqs[curIndex - 1]);
+                }
+                assignToSegment(attribution, segment);
+                cumulativeSegPos += segment.cachedLength;
             }
-            if (posBreakpoints[curIndex] === cumulativeSegPos + segment.cachedLength) {
-                currentInfo = seqs[curIndex];
+        };
+        extractOntoSegments(summary, (collection, segment) => {
+            segment.attribution = collection;
+        });
+        if (channels) {
+            for (const [name, collectionSpec] of Object.entries(channels)) {
+                extractOntoSegments(collectionSpec, (collection, segment) => {
+                    var _a;
+                    var _b;
+                    // Cast is valid as we just assigned this field above
+                    ((_a = (_b = segment.attribution).channels) !== null && _a !== void 0 ? _a : (_b.channels = {}))[name] =
+                        collection;
+                });
             }
-            segment.attribution = attribution;
-            cumulativeSegPos += segment.cachedLength;
         }
     }
     /**
      * Condenses attribution information on consecutive segments into a `SerializedAttributionCollection`
+     *
+     * Note: this operates on segments rather than attribution collections directly so that it can handle cases
+     * where only some segments have attribution defined.
      */
     static serializeAttributionCollections(segments) {
-        var _a, _b;
-        const posBreakpoints = [];
-        const seqs = [];
-        let mostRecentAttributionKey;
-        let cumulativePos = 0;
-        let segmentsWithAttribution = 0;
-        let segmentsWithoutAttribution = 0;
+        var _a;
+        const allCollectionSpecs = [];
+        const allChannelNames = new Set();
         for (const segment of segments) {
-            if (segment.attribution) {
-                segmentsWithAttribution++;
-                for (const { offset, key } of (_b = (_a = segment.attribution) === null || _a === void 0 ? void 0 : _a.getAll()) !== null && _b !== void 0 ? _b : []) {
-                    if (!mostRecentAttributionKey ||
+            const collection = (_a = segment.attribution) !== null && _a !== void 0 ? _a : new AttributionCollection(segment.cachedLength, null);
+            const spec = collection.getAll();
+            allCollectionSpecs.push(spec);
+            if (spec.channels) {
+                for (const name of Object.keys(spec.channels)) {
+                    allChannelNames.add(name);
+                }
+            }
+        }
+        const extractSequenceOffsets = (getSpecEntries) => {
+            const posBreakpoints = [];
+            const seqs = [];
+            let mostRecentAttributionKey;
+            let cumulativePos = 0;
+            for (const spec of allCollectionSpecs) {
+                for (const { offset, key } of getSpecEntries(spec)) {
+                    (0, common_utils_1.assert)((key === null || key === void 0 ? void 0 : key.type) !== "local", 0x5c1 /* local attribution keys should never be put in summaries */);
+                    if (mostRecentAttributionKey === undefined ||
                         !areEqualAttributionKeys(key, mostRecentAttributionKey)) {
                         posBreakpoints.push(offset + cumulativePos);
-                        seqs.push(key.type === "op" ? key.seq : key);
+                        seqs.push(!key ? null : key.type === "op" ? key.seq : key);
                     }
                     mostRecentAttributionKey = key;
                 }
+                cumulativePos += spec.length;
             }
-            else {
-                segmentsWithoutAttribution++;
+            return { seqs, posBreakpoints, length: cumulativePos };
+        };
+        const blobContents = extractSequenceOffsets((spec) => spec.root);
+        if (allChannelNames.size > 0) {
+            const channels = {};
+            for (const name of allChannelNames) {
+                const { posBreakpoints, seqs } = extractSequenceOffsets((spec) => { var _a, _b; return (_b = (_a = spec.channels) === null || _a === void 0 ? void 0 : _a[name]) !== null && _b !== void 0 ? _b : [{ offset: 0, key: null }]; });
+                channels[name] = { posBreakpoints, seqs };
             }
-            cumulativePos += segment.cachedLength;
+            blobContents.channels = channels;
         }
-        (0, common_utils_1.assert)(segmentsWithAttribution === 0 || segmentsWithoutAttribution === 0, 0x446 /* Expected either all segments or no segments to have attribution information. */);
-        const blobContents = {
-            seqs,
-            posBreakpoints,
-            length: cumulativePos,
-        };
         return blobContents;
     }
 }
 exports.AttributionCollection = AttributionCollection;
-/**
- * @alpha
- * @returns - An {@link AttributionPolicy} which tracks only insertion of content.
- * Content is only attributed at ack time, unless the container is in a detached state.
- * Detached content is attributed with a {@link @fluidframework/runtime-definitions#DetachedAttributionKey}.
- */
-function createInsertOnlyAttributionPolicy() {
-    let unsubscribe;
-    return {
-        attach: (client) => {
-            (0, common_utils_1.assert)(unsubscribe === undefined, 0x557 /* cannot attach to multiple clients at once */);
-            const deltaCallback = (opArgs, { deltaSegments, operation }) => {
-                var _a;
-                if (operation !== ops_1.MergeTreeDeltaType.INSERT) {
-                    return;
-                }
-                for (const { segment } of deltaSegments) {
-                    if (segment.seq !== undefined && segment.seq !== constants_1.UnassignedSequenceNumber) {
-                        const key = segment.seq === constants_1.UniversalSequenceNumber
-                            ? { type: "detached", id: 0 }
-                            : { type: "op", seq: segment.seq };
-                        (_a = segment.attribution) !== null && _a !== void 0 ? _a : (segment.attribution = new AttributionCollection(key, segment.cachedLength));
-                    }
-                }
-            };
-            const maintenanceCallback = ({ deltaSegments, operation }, opArgs) => {
-                if (operation !== mergeTreeDeltaCallback_1.MergeTreeMaintenanceType.ACKNOWLEDGED ||
-                    opArgs === undefined ||
-                    opArgs.op.type !== ops_1.MergeTreeDeltaType.INSERT) {
-                    return;
-                }
-                for (const { segment } of deltaSegments) {
-                    (0, common_utils_1.assert)(segment.seq !== undefined, 0x558 /* segment.seq should be set after ack. */);
-                    segment.attribution = new AttributionCollection({ type: "op", seq: segment.seq }, segment.cachedLength);
-                }
-            };
-            client.on("delta", deltaCallback);
-            client.on("maintenance", maintenanceCallback);
-            unsubscribe = () => {
-                client.off("delta", deltaCallback);
-                client.off("maintenance", maintenanceCallback);
-            };
-        },
-        detach: () => {
-            unsubscribe === null || unsubscribe === void 0 ? void 0 : unsubscribe();
-            unsubscribe = undefined;
-        },
-        get isAttached() {
-            return unsubscribe !== undefined;
-        },
-        serializer: AttributionCollection,
-    };
-}
-exports.createInsertOnlyAttributionPolicy = createInsertOnlyAttributionPolicy;
 //# sourceMappingURL=attributionCollection.js.map