@fluidframework/sequence 1.4.0-121020 → 2.0.0-dev-rc.1.0.0.224419

package/dist/intervalCollection.js

@@ -1,1250 +0,0 @@
-"use strict";
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IntervalCollection = exports.IntervalCollectionIterator = exports.IntervalCollectionValueType = exports.SequenceIntervalCollectionValueType = exports.LocalIntervalCollection = exports.createIntervalIndex = exports.defaultIntervalConflictResolver = exports.SequenceInterval = exports.Interval = exports.IntervalType = void 0;
-/* eslint-disable no-bitwise */
-const common_utils_1 = require("@fluidframework/common-utils");
-const container_utils_1 = require("@fluidframework/container-utils");
-const merge_tree_1 = require("@fluidframework/merge-tree");
-const telemetry_utils_1 = require("@fluidframework/telemetry-utils");
-const uuid_1 = require("uuid");
-const reservedIntervalIdKey = "intervalId";
-var IntervalType;
-(function (IntervalType) {
-    IntervalType[IntervalType["Simple"] = 0] = "Simple";
-    IntervalType[IntervalType["Nest"] = 1] = "Nest";
-    /**
-     * SlideOnRemove indicates that the ends of the interval will slide if the segment
-     * they reference is removed and acked.
-     * See `packages\dds\merge-tree\REFERENCEPOSITIONS.md` for details
-     * SlideOnRemove is the default interval behavior and does not need to be specified.
-     */
-    IntervalType[IntervalType["SlideOnRemove"] = 2] = "SlideOnRemove";
-    /**
-     * @internal
-     * A temporary interval, used internally
-     */
-    IntervalType[IntervalType["Transient"] = 4] = "Transient";
-})(IntervalType = exports.IntervalType || (exports.IntervalType = {}));
-/**
- * Decompress an interval after loading a summary from JSON. The exact format
- * of this compression is unspecified and subject to change
- */
-function decompressInterval(interval, label) {
-    return {
-        start: interval[0],
-        end: interval[1],
-        sequenceNumber: interval[2],
-        intervalType: interval[3],
-        properties: Object.assign(Object.assign({}, interval[4]), { [merge_tree_1.reservedRangeLabelsKey]: label }),
-    };
-}
-/**
- * Compress an interval prior to serialization as JSON. The exact format of this
- * compression is unspecified and subject to change
- */
-function compressInterval(interval) {
-    const { start, end, sequenceNumber, intervalType, properties } = interval;
-    return [
-        start,
-        end,
-        sequenceNumber,
-        intervalType,
-        Object.assign(Object.assign({}, properties), { [merge_tree_1.reservedRangeLabelsKey]: undefined }),
-    ];
-}
-class Interval {
-    constructor(start, end, props) {
-        this.start = start;
-        this.end = end;
-        this.propertyManager = new merge_tree_1.PropertiesManager();
-        this.properties = {};
-        if (props) {
-            this.addProperties(props);
-        }
-    }
-    getIntervalId() {
-        var _a;
-        const id = (_a = this.properties) === null || _a === void 0 ? void 0 : _a[reservedIntervalIdKey];
-        if (id === undefined) {
-            return undefined;
-        }
-        return `${id}`;
-    }
-    getAdditionalPropertySets() {
-        return this.auxProps;
-    }
-    addPropertySet(props) {
-        if (this.auxProps === undefined) {
-            this.auxProps = [];
-        }
-        this.auxProps.push(props);
-    }
-    serialize(client) {
-        let seq = 0;
-        if (client) {
-            seq = client.getCurrentSeq();
-        }
-        const serializedInterval = {
-            end: this.end,
-            intervalType: 0,
-            sequenceNumber: seq,
-            start: this.start,
-        };
-        if (this.properties) {
-            serializedInterval.properties = this.properties;
-        }
-        return serializedInterval;
-    }
-    clone() {
-        return new Interval(this.start, this.end, this.properties);
-    }
-    compare(b) {
-        const startResult = this.compareStart(b);
-        if (startResult === 0) {
-            const endResult = this.compareEnd(b);
-            if (endResult === 0) {
-                const thisId = this.getIntervalId();
-                if (thisId) {
-                    const bId = b.getIntervalId();
-                    if (bId) {
-                        return thisId > bId ? 1 : thisId < bId ? -1 : 0;
-                    }
-                    return 0;
-                }
-                return 0;
-            }
-            else {
-                return endResult;
-            }
-        }
-        else {
-            return startResult;
-        }
-    }
-    compareStart(b) {
-        return this.start - b.start;
-    }
-    compareEnd(b) {
-        return this.end - b.end;
-    }
-    overlaps(b) {
-        const result = (this.start <= b.end) &&
-            (this.end >= b.start);
-        return result;
-    }
-    union(b) {
-        return new Interval(Math.min(this.start, b.start), Math.max(this.end, b.end), this.properties);
-    }
-    getProperties() {
-        return this.properties;
-    }
-    addProperties(newProps, collaborating = false, seq, op) {
-        if (newProps) {
-            this.initializeProperties();
-            return this.propertyManager.addProperties(this.properties, newProps, op, seq, collaborating);
-        }
-    }
-    modify(label, start, end, op) {
-        const startPos = start !== null && start !== void 0 ? start : this.start;
-        const endPos = end !== null && end !== void 0 ? end : this.end;
-        if (this.start === startPos && this.end === endPos) {
-            // Return undefined to indicate that no change is necessary.
-            return;
-        }
-        const newInterval = new Interval(startPos, endPos);
-        if (this.properties) {
-            newInterval.initializeProperties();
-            this.propertyManager.copyTo(this.properties, newInterval.properties, newInterval.propertyManager);
-        }
-        return newInterval;
-    }
-    initializeProperties() {
-        if (!this.propertyManager) {
-            this.propertyManager = new merge_tree_1.PropertiesManager();
-        }
-        if (!this.properties) {
-            this.properties = (0, merge_tree_1.createMap)();
-        }
-    }
-}
-exports.Interval = Interval;
-class SequenceInterval {
-    constructor(start, end, intervalType, props) {
-        this.start = start;
-        this.end = end;
-        this.intervalType = intervalType;
-        this.propertyManager = new merge_tree_1.PropertiesManager();
-        this.properties = {};
-        if (props) {
-            this.addProperties(props);
-        }
-    }
-    /**
-     * @internal
-     * Subscribes to position change events on this interval if there are no current listeners.
-     */
-    addPositionChangeListeners(beforePositionChange, afterPositionChange) {
-        var _a, _b;
-        var _c, _d;
-        if (this.callbacks === undefined) {
-            this.callbacks = {
-                beforePositionChange,
-                afterPositionChange,
-            };
-            const startCbs = (_a = (_c = this.start).callbacks) !== null && _a !== void 0 ? _a : (_c.callbacks = {});
-            const endCbs = (_b = (_d = this.end).callbacks) !== null && _b !== void 0 ? _b : (_d.callbacks = {});
-            startCbs.beforeSlide = endCbs.beforeSlide = beforePositionChange;
-            startCbs.afterSlide = endCbs.afterSlide = afterPositionChange;
-        }
-    }
-    /**
-     * @internal
-     * Removes the currently subscribed position change listeners.
-     */
-    removePositionChangeListeners() {
-        if (this.callbacks) {
-            this.callbacks = undefined;
-            this.start.callbacks = undefined;
-            this.end.callbacks = undefined;
-        }
-    }
-    serialize(client) {
-        const startPosition = this.start.toPosition();
-        const endPosition = this.end.toPosition();
-        const serializedInterval = {
-            end: endPosition,
-            intervalType: this.intervalType,
-            sequenceNumber: client.getCurrentSeq(),
-            start: startPosition,
-        };
-        if (this.properties) {
-            serializedInterval.properties = this.properties;
-        }
-        return serializedInterval;
-    }
-    clone() {
-        return new SequenceInterval(this.start, this.end, this.intervalType, this.properties);
-    }
-    compare(b) {
-        const startResult = this.compareStart(b);
-        if (startResult === 0) {
-            const endResult = this.compareEnd(b);
-            if (endResult === 0) {
-                const thisId = this.getIntervalId();
-                if (thisId) {
-                    const bId = b.getIntervalId();
-                    if (bId) {
-                        return thisId > bId ? 1 : thisId < bId ? -1 : 0;
-                    }
-                    return 0;
-                }
-                return 0;
-            }
-            else {
-                return endResult;
-            }
-        }
-        else {
-            return startResult;
-        }
-    }
-    compareStart(b) {
-        return this.start.compare(b.start);
-    }
-    compareEnd(b) {
-        return this.end.compare(b.end);
-    }
-    overlaps(b) {
-        const result = (this.start.compare(b.end) <= 0) &&
-            (this.end.compare(b.start) >= 0);
-        return result;
-    }
-    getIntervalId() {
-        var _a;
-        const id = (_a = this.properties) === null || _a === void 0 ? void 0 : _a[reservedIntervalIdKey];
-        if (id === undefined) {
-            return undefined;
-        }
-        return `${id}`;
-    }
-    union(b) {
-        return new SequenceInterval(this.start.min(b.start), this.end.max(b.end), this.intervalType);
-    }
-    addProperties(newProps, collab = false, seq, op) {
-        this.initializeProperties();
-        return this.propertyManager.addProperties(this.properties, newProps, op, seq, collab);
-    }
-    overlapsPos(bstart, bend) {
-        const startPos = this.start.toPosition();
-        const endPos = this.start.toPosition();
-        return (endPos > bstart) && (startPos < bend);
-    }
-    modify(label, start, end, op) {
-        const getRefType = (baseType) => {
-            let refType = baseType;
-            if (op === undefined) {
-                refType &= ~merge_tree_1.ReferenceType.SlideOnRemove;
-                refType |= merge_tree_1.ReferenceType.StayOnRemove;
-            }
-            return refType;
-        };
-        let startRef = this.start;
-        if (start !== undefined) {
-            startRef = createPositionReference(this.start.getClient(), start, getRefType(this.start.refType), op);
-            startRef.addProperties(this.start.properties);
-        }
-        let endRef = this.end;
-        if (end !== undefined) {
-            endRef = createPositionReference(this.end.getClient(), end, getRefType(this.end.refType), op);
-            endRef.addProperties(this.end.properties);
-        }
-        startRef.pairedRef = endRef;
-        endRef.pairedRef = startRef;
-        const newInterval = new SequenceInterval(startRef, endRef, this.intervalType);
-        if (this.properties) {
-            newInterval.initializeProperties();
-            this.propertyManager.copyTo(this.properties, newInterval.properties, newInterval.propertyManager);
-        }
-        return newInterval;
-    }
-    initializeProperties() {
-        if (!this.propertyManager) {
-            this.propertyManager = new merge_tree_1.PropertiesManager();
-        }
-        if (!this.properties) {
-            this.properties = (0, merge_tree_1.createMap)();
-        }
-    }
-}
-exports.SequenceInterval = SequenceInterval;
-function createPositionReferenceFromSegoff(client, segoff, refType, op) {
-    if (segoff.segment) {
-        const ref = client.createLocalReferencePosition(segoff.segment, segoff.offset, refType, undefined);
-        return ref;
-    }
-    else {
-        if (!op && !(0, merge_tree_1.refTypeIncludesFlag)(refType, merge_tree_1.ReferenceType.Transient)) {
-            throw new container_utils_1.UsageError("Non-transient references need segment");
-        }
-        return new merge_tree_1.LocalReference(client, undefined, 0, refType);
-    }
-}
-function createPositionReference(client, pos, refType, op) {
-    let segoff;
-    if (op) {
-        (0, common_utils_1.assert)((refType & merge_tree_1.ReferenceType.SlideOnRemove) !== 0, 0x2f5 /* op create references must be SlideOnRemove */);
-        segoff = client.getContainingSegment(pos, op);
-        segoff = client.getSlideToSegment(segoff);
-    }
-    else {
-        (0, common_utils_1.assert)((refType & merge_tree_1.ReferenceType.SlideOnRemove) === 0, 0x2f6 /* SlideOnRemove references must be op created */);
-        segoff = client.getContainingSegment(pos);
-    }
-    return createPositionReferenceFromSegoff(client, segoff, refType, op);
-}
-function createSequenceInterval(label, start, end, client, intervalType, op) {
-    let beginRefType = merge_tree_1.ReferenceType.RangeBegin;
-    let endRefType = merge_tree_1.ReferenceType.RangeEnd;
-    if (intervalType === IntervalType.Transient) {
-        beginRefType = merge_tree_1.ReferenceType.Transient;
-        endRefType = merge_tree_1.ReferenceType.Transient;
-    }
-    else {
-        if (intervalType === IntervalType.Nest) {
-            beginRefType = merge_tree_1.ReferenceType.NestBegin;
-            endRefType = merge_tree_1.ReferenceType.NestEnd;
-        }
-        // All non-transient interval references must eventually be SlideOnRemove
-        // To ensure eventual consistency, they must start as StayOnRemove when
-        // pending (created locally and creation op is not acked)
-        if (op) {
-            beginRefType |= merge_tree_1.ReferenceType.SlideOnRemove;
-            endRefType |= merge_tree_1.ReferenceType.SlideOnRemove;
-        }
-        else {
-            beginRefType |= merge_tree_1.ReferenceType.StayOnRemove;
-            endRefType |= merge_tree_1.ReferenceType.StayOnRemove;
-        }
-    }
-    const startLref = createPositionReference(client, start, beginRefType, op);
-    const endLref = createPositionReference(client, end, endRefType, op);
-    startLref.pairedRef = endLref;
-    endLref.pairedRef = startLref;
-    const rangeProp = {
-        [merge_tree_1.reservedRangeLabelsKey]: [label],
-    };
-    startLref.addProperties(rangeProp);
-    endLref.addProperties(rangeProp);
-    const ival = new SequenceInterval(startLref, endLref, intervalType, rangeProp);
-    return ival;
-}
-function defaultIntervalConflictResolver(a, b) {
-    a.addPropertySet(b.properties);
-    return a;
-}
-exports.defaultIntervalConflictResolver = defaultIntervalConflictResolver;
-function createIntervalIndex(conflict) {
-    const helpers = {
-        compareEnds: compareIntervalEnds,
-        create: createInterval,
-    };
-    const lc = new LocalIntervalCollection(undefined, "", helpers);
-    if (conflict) {
-        lc.addConflictResolver(conflict);
-    }
-    else {
-        lc.addConflictResolver(defaultIntervalConflictResolver);
-    }
-    return lc;
-}
-exports.createIntervalIndex = createIntervalIndex;
-class LocalIntervalCollection {
-    constructor(client, label, helpers, 
-    /** Callback invoked each time one of the endpoints of an interval slides. */
-    onPositionChange) {
-        this.client = client;
-        this.label = label;
-        this.helpers = helpers;
-        this.onPositionChange = onPositionChange;
-        this.intervalTree = new merge_tree_1.IntervalTree();
-        this.intervalIdMap = new Map();
-        // eslint-disable-next-line @typescript-eslint/unbound-method
-        this.endIntervalTree = new merge_tree_1.RedBlackTree(helpers.compareEnds);
-    }
-    addConflictResolver(conflictResolver) {
-        this.conflictResolver = conflictResolver;
-        this.endConflictResolver =
-            (key, currentKey) => {
-                const ival = conflictResolver(key, currentKey);
-                return {
-                    data: ival,
-                    key: ival,
-                };
-            };
-    }
-    map(fn) {
-        this.intervalTree.map(fn);
-    }
-    createLegacyId(start, end) {
-        // Create a non-unique ID based on start and end to be used on intervals that come from legacy clients
-        // without ID's.
-        return `${LocalIntervalCollection.legacyIdPrefix}${start}-${end}`;
-    }
-    /**
-     * Validates that a serialized interval has the ID property. Creates an ID
-     * if one does not already exist
-     *
-     * @param serializedInterval - The interval to be checked
-     * @returns The interval's existing or newly created id
-     */
-    ensureSerializedId(serializedInterval) {
-        var _a;
-        let id = (_a = serializedInterval.properties) === null || _a === void 0 ? void 0 : _a[reservedIntervalIdKey];
-        if (id === undefined) {
-            // An interval came over the wire without an ID, so create a non-unique one based on start/end.
-            // This will allow all clients to refer to this interval consistently.
-            id = this.createLegacyId(serializedInterval.start, serializedInterval.end);
-            const newProps = {
-                [reservedIntervalIdKey]: id,
-            };
-            serializedInterval.properties = (0, merge_tree_1.addProperties)(serializedInterval.properties, newProps);
-        }
-        // Make the ID immutable for safety's sake.
-        Object.defineProperty(serializedInterval.properties, reservedIntervalIdKey, {
-            configurable: false,
-            enumerable: true,
-            writable: false,
-        });
-        return id;
-    }
-    mapUntil(fn) {
-        this.intervalTree.mapUntil(fn);
-    }
-    gatherIterationResults(results, iteratesForward, start, end) {
-        if (this.intervalTree.intervals.isEmpty()) {
-            return;
-        }
-        if (start === undefined && end === undefined) {
-            // No start/end provided. Gather the whole tree in the specified order.
-            if (iteratesForward) {
-                this.intervalTree.map((interval) => {
-                    results.push(interval);
-                });
-            }
-            else {
-                this.intervalTree.mapBackward((interval) => {
-                    results.push(interval);
-                });
-            }
-        }
-        else {
-            const transientInterval = this.helpers.create("transient", start, end, this.client, IntervalType.Transient);
-            if (start === undefined) {
-                // Only end position provided. Since the tree is not sorted by end position,
-                // walk the whole tree in the specified order, gathering intervals that match the end.
-                if (iteratesForward) {
-                    this.intervalTree.map((interval) => {
-                        if (transientInterval.compareEnd(interval) === 0) {
-                            results.push(interval);
-                        }
-                    });
-                }
-                else {
-                    this.intervalTree.mapBackward((interval) => {
-                        if (transientInterval.compareEnd(interval) === 0) {
-                            results.push(interval);
-                        }
-                    });
-                }
-            }
-            else {
-                // Start and (possibly) end provided. Walk the subtrees that may contain
-                // this start position.
-                const compareFn = end === undefined ?
-                    (node) => {
-                        return transientInterval.compareStart(node.key);
-                    } :
-                    (node) => {
-                        return transientInterval.compare(node.key);
-                    };
-                const continueLeftFn = (cmpResult) => cmpResult <= 0;
-                const continueRightFn = (cmpResult) => cmpResult >= 0;
-                const actionFn = (node) => {
-                    results.push(node.key);
-                };
-                if (iteratesForward) {
-                    this.intervalTree.intervals.walkExactMatchesForward(compareFn, actionFn, continueLeftFn, continueRightFn);
-                }
-                else {
-                    this.intervalTree.intervals.walkExactMatchesBackward(compareFn, actionFn, continueLeftFn, continueRightFn);
-                }
-            }
-        }
-    }
-    findOverlappingIntervals(startPosition, endPosition) {
-        if (endPosition < startPosition || this.intervalTree.intervals.isEmpty()) {
-            return [];
-        }
-        const transientInterval = this.helpers.create("transient", startPosition, endPosition, this.client, IntervalType.Transient);
-        const overlappingIntervalNodes = this.intervalTree.match(transientInterval);
-        return overlappingIntervalNodes.map((node) => node.key);
-    }
-    previousInterval(pos) {
-        const transientInterval = this.helpers.create("transient", pos, pos, this.client, IntervalType.Transient);
-        const rbNode = this.endIntervalTree.floor(transientInterval);
-        if (rbNode) {
-            return rbNode.data;
-        }
-    }
-    nextInterval(pos) {
-        const transientInterval = this.helpers.create("transient", pos, pos, this.client, IntervalType.Transient);
-        const rbNode = this.endIntervalTree.ceil(transientInterval);
-        if (rbNode) {
-            return rbNode.data;
-        }
-    }
-    removeInterval(startPosition, endPosition) {
-        const transientInterval = this.helpers.create("transient", startPosition, endPosition, this.client, IntervalType.Transient);
-        this.intervalTree.remove(transientInterval);
-        this.endIntervalTree.remove(transientInterval);
-        return transientInterval;
-    }
-    removeIntervalFromIndex(interval) {
-        this.intervalTree.removeExisting(interval);
-        this.endIntervalTree.remove(interval);
-        const id = interval.getIntervalId();
-        (0, common_utils_1.assert)(id !== undefined, 0x311 /* expected id to exist on interval */);
-        this.intervalIdMap.delete(id);
-    }
-    removeExistingInterval(interval) {
-        this.removeIntervalFromIndex(interval);
-        this.removeIntervalListeners(interval);
-    }
-    createInterval(start, end, intervalType, op) {
-        return this.helpers.create(this.label, start, end, this.client, intervalType, op);
-    }
-    addInterval(start, end, intervalType, props, op) {
-        const interval = this.createInterval(start, end, intervalType, op);
-        if (interval) {
-            if (!interval.properties) {
-                interval.properties = (0, merge_tree_1.createMap)();
-            }
-            if (props) {
-                interval.addProperties(props);
-            }
-            if (interval.properties[reservedIntervalIdKey] === undefined) {
-                // Create a new ID.
-                interval.properties[reservedIntervalIdKey] = (0, uuid_1.v4)();
-            }
-            this.add(interval);
-        }
-        return interval;
-    }
-    addIntervalToIndex(interval) {
-        const id = interval.getIntervalId();
-        (0, common_utils_1.assert)(id !== undefined, 0x2c0 /* "ID must be created before adding interval to collection" */);
-        // Make the ID immutable.
-        Object.defineProperty(interval.properties, reservedIntervalIdKey, {
-            configurable: false,
-            enumerable: true,
-            writable: false,
-        });
-        this.intervalTree.put(interval, this.conflictResolver);
-        this.endIntervalTree.put(interval, interval, this.endConflictResolver);
-        this.intervalIdMap.set(id, interval);
-    }
-    add(interval) {
-        this.addIntervalToIndex(interval);
-        this.addIntervalListeners(interval);
-    }
-    getIntervalById(id) {
-        return this.intervalIdMap.get(id);
-    }
-    changeInterval(interval, start, end, op) {
-        const newInterval = interval.modify(this.label, start, end, op);
-        if (newInterval) {
-            this.removeExistingInterval(interval);
-            this.add(newInterval);
-        }
-        return newInterval;
-    }
-    serialize() {
-        const client = this.client;
-        const intervals = this.intervalTree.intervals.keys();
-        return {
-            label: this.label,
-            intervals: intervals.map((interval) => compressInterval(interval.serialize(client))),
-            version: 2,
-        };
-    }
-    addIntervalListeners(interval) {
-        if (interval instanceof SequenceInterval) {
-            interval.addPositionChangeListeners(() => this.removeIntervalFromIndex(interval), () => {
-                var _a;
-                this.addIntervalToIndex(interval);
-                (_a = this.onPositionChange) === null || _a === void 0 ? void 0 : _a.call(this, interval);
-            });
-        }
-    }
-    removeIntervalListeners(interval) {
-        if (interval instanceof SequenceInterval) {
-            interval.removePositionChangeListeners();
-        }
-    }
-}
-exports.LocalIntervalCollection = LocalIntervalCollection;
-LocalIntervalCollection.legacyIdPrefix = "legacy";
-const compareSequenceIntervalEnds = (a, b) => a.end.compare(b.end);
-class SequenceIntervalCollectionFactory {
-    load(emitter, raw = []) {
-        const helpers = {
-            compareEnds: compareSequenceIntervalEnds,
-            create: createSequenceInterval,
-        };
-        return new IntervalCollection(helpers, true, emitter, raw);
-    }
-    store(value) {
-        return value.serializeInternal();
-    }
-}
-class SequenceIntervalCollectionValueType {
-    get name() {
-        return SequenceIntervalCollectionValueType.Name;
-    }
-    get factory() {
-        return SequenceIntervalCollectionValueType._factory;
-    }
-    get ops() {
-        return SequenceIntervalCollectionValueType._ops;
-    }
-}
-exports.SequenceIntervalCollectionValueType = SequenceIntervalCollectionValueType;
-SequenceIntervalCollectionValueType.Name = "sharedStringIntervalCollection";
-SequenceIntervalCollectionValueType._factory = new SequenceIntervalCollectionFactory();
-SequenceIntervalCollectionValueType._ops = makeOpsMap();
-const compareIntervalEnds = (a, b) => a.end - b.end;
-function createInterval(label, start, end, client) {
-    const rangeProp = {};
-    if (label && label.length > 0) {
-        rangeProp[merge_tree_1.reservedRangeLabelsKey] = [label];
-    }
-    return new Interval(start, end, rangeProp);
-}
-class IntervalCollectionFactory {
-    load(emitter, raw = []) {
-        const helpers = {
-            compareEnds: compareIntervalEnds,
-            create: createInterval,
-        };
-        const collection = new IntervalCollection(helpers, false, emitter, raw);
-        collection.attachGraph(undefined, "");
-        return collection;
-    }
-    store(value) {
-        return value.serializeInternal();
-    }
-}
-class IntervalCollectionValueType {
-    get name() {
-        return IntervalCollectionValueType.Name;
-    }
-    get factory() {
-        return IntervalCollectionValueType._factory;
-    }
-    get ops() {
-        return IntervalCollectionValueType._ops;
-    }
-}
-exports.IntervalCollectionValueType = IntervalCollectionValueType;
-IntervalCollectionValueType.Name = "sharedIntervalCollection";
-IntervalCollectionValueType._factory = new IntervalCollectionFactory();
-IntervalCollectionValueType._ops = makeOpsMap();
-function makeOpsMap() {
-    const rebase = (collection, op, localOpMetadata) => {
-        const { localSeq } = localOpMetadata;
-        const rebasedValue = collection.rebaseLocalInterval(op.opName, op.value, localSeq);
-        const rebasedOp = Object.assign(Object.assign({}, op), { value: rebasedValue });
-        return { rebasedOp, rebasedLocalOpMetadata: localOpMetadata };
-    };
-    return new Map([[
-            "add",
-            {
-                process: (collection, params, local, op) => {
-                    collection.ackAdd(params, local, op);
-                },
-                rebase,
-            },
-        ],
-        [
-            "delete",
-            {
-                process: (collection, params, local, op) => {
-                    collection.ackDelete(params, local, op);
-                },
-                rebase: (collection, op, localOpMetadata) => {
-                    // Deletion of intervals is based on id, so requires no rebasing.
-                    return { rebasedOp: op, rebasedLocalOpMetadata: localOpMetadata };
-                },
-            },
-        ],
-        [
-            "change",
-            {
-                process: (collection, params, local, op) => {
-                    collection.ackChange(params, local, op);
-                },
-                rebase,
-            },
-        ]]);
-}
-class IntervalCollectionIterator {
-    constructor(collection, iteratesForward = true, start, end) {
-        this.results = [];
-        this.index = 0;
-        collection.gatherIterationResults(this.results, iteratesForward, start, end);
-    }
-    next() {
-        let _value;
-        let _done = true;
-        if (this.index < this.results.length) {
-            _value = this.results[this.index++];
-            _done = false;
-        }
-        return {
-            value: _value,
-            done: _done,
-        };
-    }
-}
-exports.IntervalCollectionIterator = IntervalCollectionIterator;
-class IntervalCollection extends common_utils_1.TypedEventEmitter {
-    /** @internal */
-    constructor(helpers, requiresClient, emitter, serializedIntervals) {
-        super();
-        this.helpers = helpers;
-        this.requiresClient = requiresClient;
-        this.emitter = emitter;
-        this.pendingChangesStart = new Map();
-        this.pendingChangesEnd = new Map();
-        if (Array.isArray(serializedIntervals)) {
-            this.savedSerializedIntervals = serializedIntervals;
-        }
-        else {
-            this.savedSerializedIntervals =
-                serializedIntervals.intervals.map((i) => decompressInterval(i, serializedIntervals.label));
-        }
-    }
-    get attached() {
-        return !!this.localCollection;
-    }
-    attachGraph(client, label) {
-        if (this.attached) {
-            throw new telemetry_utils_1.LoggingError("Only supports one Sequence attach");
-        }
-        if ((client === undefined) && (this.requiresClient)) {
-            throw new telemetry_utils_1.LoggingError("Client required for this collection");
-        }
-        // Instantiate the local interval collection based on the saved intervals
-        this.client = client;
-        this.localCollection = new LocalIntervalCollection(client, label, this.helpers, (interval) => this.emit("changeInterval", interval, true, undefined));
-        if (this.savedSerializedIntervals) {
-            for (const serializedInterval of this.savedSerializedIntervals) {
-                this.localCollection.ensureSerializedId(serializedInterval);
-                this.localCollection.addInterval(serializedInterval.start, serializedInterval.end, serializedInterval.intervalType, serializedInterval.properties);
-            }
-        }
-        this.savedSerializedIntervals = undefined;
-    }
-    /**
-     * Gets the next local sequence number, modifying this client's collab window in doing so.
-     */
-    getNextLocalSeq() {
-        return ++this.client.getCollabWindow().localSeq;
-    }
-    getIntervalById(id) {
-        if (!this.attached) {
-            throw new telemetry_utils_1.LoggingError("attach must be called before accessing intervals");
-        }
-        return this.localCollection.getIntervalById(id);
-    }
-    /**
-     * Create a new interval and add it to the collection
-     * @param start - interval start position
-     * @param end - interval end position
-     * @param intervalType - type of the interval. All intervals are SlideOnRemove. Intervals may not be Transient.
-     * @param props - properties of the interval
-     * @returns - the created interval
-     */
-    add(start, end, intervalType, props) {
-        var _a, _b;
-        if (!this.attached) {
-            throw new telemetry_utils_1.LoggingError("attach must be called prior to adding intervals");
-        }
-        if (intervalType & IntervalType.Transient) {
-            throw new telemetry_utils_1.LoggingError("Can not add transient intervals");
-        }
-        const interval = this.localCollection.addInterval(start, end, intervalType, props);
-        if (interval) {
-            const serializedInterval = {
-                end,
-                intervalType,
-                properties: interval.properties,
-                sequenceNumber: (_b = (_a = this.client) === null || _a === void 0 ? void 0 : _a.getCurrentSeq()) !== null && _b !== void 0 ? _b : 0,
-                start,
-            };
-            // Local ops get submitted to the server. Remote ops have the deserializer run.
-            this.emitter.emit("add", undefined, serializedInterval, { localSeq: this.getNextLocalSeq() });
-        }
-        this.emit("addInterval", interval, true, undefined);
-        return interval;
-    }
-    deleteExistingInterval(interval, local, op) {
-        // The given interval is known to exist in the collection.
-        this.localCollection.removeExistingInterval(interval);
-        if (interval) {
-            // Local ops get submitted to the server. Remote ops have the deserializer run.
-            if (local) {
-                this.emitter.emit("delete", undefined, interval.serialize(this.client), { localSeq: this.getNextLocalSeq() });
-            }
-            else {
-                if (this.onDeserialize) {
-                    this.onDeserialize(interval);
-                }
-            }
-        }
-        this.emit("deleteInterval", interval, local, op);
-    }
-    removeIntervalById(id) {
-        const interval = this.localCollection.getIntervalById(id);
-        if (interval) {
-            this.deleteExistingInterval(interval, true, undefined);
-        }
-        return interval;
-    }
-    changeProperties(id, props) {
-        if (!this.attached) {
-            throw new telemetry_utils_1.LoggingError("Attach must be called before accessing intervals");
-        }
-        if (typeof (id) !== "string") {
-            throw new telemetry_utils_1.LoggingError("Change API requires an ID that is a string");
-        }
-        if (!props) {
-            throw new telemetry_utils_1.LoggingError("changeProperties should be called with a property set");
-        }
-        const interval = this.getIntervalById(id);
-        if (interval) {
-            // Pass Unassigned as the sequence number to indicate that this is a local op that is waiting for an ack.
-            const deltaProps = interval.addProperties(props, true, merge_tree_1.UnassignedSequenceNumber);
-            const serializedInterval = interval.serialize(this.client);
-            // Emit a change op that will only change properties. Add the ID to
-            // the property bag provided by the caller.
-            serializedInterval.start = undefined;
-            serializedInterval.end = undefined;
-            serializedInterval.properties = props;
-            serializedInterval.properties[reservedIntervalIdKey] = interval.getIntervalId();
-            this.emitter.emit("change", undefined, serializedInterval, { localSeq: this.getNextLocalSeq() });
-            this.emit("propertyChanged", interval, deltaProps);
-        }
-        this.emit("changeInterval", interval, true, undefined);
-    }
-    change(id, start, end) {
-        if (!this.attached) {
-            throw new telemetry_utils_1.LoggingError("Attach must be called before accessing intervals");
-        }
-        // Force id to be a string.
-        if (typeof (id) !== "string") {
-            throw new telemetry_utils_1.LoggingError("Change API requires an ID that is a string");
-        }
-        const interval = this.getIntervalById(id);
-        if (interval) {
-            const newInterval = this.localCollection.changeInterval(interval, start, end);
-            const serializedInterval = interval.serialize(this.client);
-            serializedInterval.start = start;
-            serializedInterval.end = end;
-            // Emit a property bag containing only the ID, as we don't intend for this op to change any properties.
-            serializedInterval.properties =
-                {
-                    [reservedIntervalIdKey]: interval.getIntervalId(),
-                };
-            this.emitter.emit("change", undefined, serializedInterval, { localSeq: this.getNextLocalSeq() });
-            this.addPendingChange(id, serializedInterval);
-            this.emit("changeInterval", newInterval, true, undefined);
-            return newInterval;
-        }
-        // No interval to change
-        return undefined;
-    }
-    addPendingChange(id, serializedInterval) {
-        if (serializedInterval.start !== undefined) {
-            this.addPendingChangeHelper(id, this.pendingChangesStart, serializedInterval);
-        }
-        if (serializedInterval.end !== undefined) {
-            this.addPendingChangeHelper(id, this.pendingChangesEnd, serializedInterval);
-        }
-    }
-    addPendingChangeHelper(id, pendingChanges, serializedInterval) {
-        let entries = pendingChanges.get(id);
-        if (!entries) {
-            entries = [];
-            pendingChanges.set(id, entries);
-        }
-        entries.push(serializedInterval);
-    }
-    removePendingChange(serializedInterval) {
-        var _a;
-        // Change ops always have an ID.
-        const id = (_a = serializedInterval.properties) === null || _a === void 0 ? void 0 : _a[reservedIntervalIdKey];
-        if (serializedInterval.start !== undefined) {
-            this.removePendingChangeHelper(id, this.pendingChangesStart, serializedInterval);
-        }
-        if (serializedInterval.end !== undefined) {
-            this.removePendingChangeHelper(id, this.pendingChangesEnd, serializedInterval);
-        }
-    }
-    removePendingChangeHelper(id, pendingChanges, serializedInterval) {
-        const entries = pendingChanges.get(id);
-        if (entries) {
-            const pendingChange = entries.shift();
-            if (entries.length === 0) {
-                pendingChanges.delete(id);
-            }
-            if ((pendingChange === null || pendingChange === void 0 ? void 0 : pendingChange.start) !== serializedInterval.start ||
-                (pendingChange === null || pendingChange === void 0 ? void 0 : pendingChange.end) !== serializedInterval.end) {
-                throw new telemetry_utils_1.LoggingError("Mismatch in pending changes");
-            }
-        }
-    }
-    hasPendingChangeStart(id) {
-        const entries = this.pendingChangesStart.get(id);
-        return entries && entries.length !== 0;
-    }
-    hasPendingChangeEnd(id) {
-        const entries = this.pendingChangesEnd.get(id);
-        return entries && entries.length !== 0;
-    }
-    /** @deprecated - use ackChange */
-    changeInterval(serializedInterval, local, op) {
-        return this.ackChange(serializedInterval, local, op);
-    }
-    /** @internal */
-    ackChange(serializedInterval, local, op) {
-        var _a, _b, _c, _d;
-        if (!this.attached) {
-            throw new telemetry_utils_1.LoggingError("Attach must be called before accessing intervals");
-        }
-        let interval;
-        if (local) {
-            // This is an ack from the server. Remove the pending change.
-            this.removePendingChange(serializedInterval);
-            const id = (_a = serializedInterval.properties) === null || _a === void 0 ? void 0 : _a[reservedIntervalIdKey];
-            interval = this.getIntervalById(id);
-            if (interval) {
-                // Let the propertyManager prune its pending change-properties set.
-                (_b = interval.propertyManager) === null || _b === void 0 ? void 0 : _b.ackPendingProperties({
-                    type: merge_tree_1.MergeTreeDeltaType.ANNOTATE,
-                    props: (_c = serializedInterval.properties) !== null && _c !== void 0 ? _c : {},
-                });
-                this.ackInterval(interval, op);
-            }
-        }
-        else {
-            // If there are pending changes with this ID, don't apply the remote start/end change, as the local ack
-            // should be the winning change.
-            // Note that the ID is in the property bag only to allow us to find the interval.
-            // This API cannot change the ID, and writing to the ID property will result in an exception. So we
-            // strip it out of the properties here.
-            const _e = serializedInterval.properties, _f = reservedIntervalIdKey, id = _e[_f], newProps = __rest(_e, [typeof _f === "symbol" ? _f : _f + ""]);
-            interval = this.getIntervalById(id);
-            if (interval) {
-                let start;
-                let end;
-                // Track pending start/end independently of one another.
-                if (!this.hasPendingChangeStart(id)) {
-                    start = serializedInterval.start;
-                }
-                if (!this.hasPendingChangeEnd(id)) {
-                    end = serializedInterval.end;
-                }
-                if (start !== undefined || end !== undefined) {
-                    // If changeInterval gives us a new interval, work with that one. Otherwise keep working with
-                    // the one we originally found in the tree.
-                    interval = (_d = this.localCollection.changeInterval(interval, start, end, op)) !== null && _d !== void 0 ? _d : interval;
-                }
-                const deltaProps = interval.addProperties(newProps, true, op.sequenceNumber);
-                if (this.onDeserialize) {
-                    this.onDeserialize(interval);
-                }
-                this.emit("propertyChanged", interval, deltaProps);
-            }
-        }
-        if (interval) {
-            this.emit("changeInterval", interval, local, op);
-        }
-    }
-    addConflictResolver(conflictResolver) {
-        if (!this.attached) {
-            throw new telemetry_utils_1.LoggingError("attachSequence must be called");
-        }
-        this.localCollection.addConflictResolver(conflictResolver);
-    }
-    attachDeserializer(onDeserialize) {
-        // If no deserializer is specified can skip all processing work
-        if (!onDeserialize) {
-            return;
-        }
-        // Start by storing the callbacks so that any subsequent modifications make use of them
-        this.onDeserialize = onDeserialize;
-        // Trigger the async prepare work across all values in the collection
-        this.localCollection.map((interval) => {
-            onDeserialize(interval);
-        });
-    }
-    /** @internal */
-    rebaseLocalInterval(opName, serializedInterval, localSeq) {
-        var _a, _b;
-        if (!this.attached) {
-            throw new telemetry_utils_1.LoggingError("attachSequence must be called");
-        }
-        const { start, end, intervalType, properties, sequenceNumber } = serializedInterval;
-        const startRebased = start === undefined ? undefined :
-            this.client.rebasePosition(start, sequenceNumber, localSeq);
-        const endRebased = end === undefined ? undefined :
-            this.client.rebasePosition(end, sequenceNumber, localSeq);
-        const intervalId = properties === null || properties === void 0 ? void 0 : properties[reservedIntervalIdKey];
-        const rebased = {
-            start: startRebased,
-            end: endRebased,
-            intervalType,
-            sequenceNumber: (_b = (_a = this.client) === null || _a === void 0 ? void 0 : _a.getCurrentSeq()) !== null && _b !== void 0 ? _b : 0,
-            properties,
-        };
-        if (opName === "change" && (this.hasPendingChangeStart(intervalId) || this.hasPendingChangeEnd(intervalId))) {
-            this.removePendingChange(serializedInterval);
-            this.addPendingChange(intervalId, rebased);
-        }
-        return rebased;
-    }
-    getSlideToSegment(lref) {
-        const segoff = { segment: lref.segment, offset: lref.offset };
-        const newSegoff = this.client.getSlideToSegment(segoff);
-        const value = (segoff.segment === newSegoff.segment && segoff.offset === newSegoff.offset) ? undefined : newSegoff;
-        return value;
-    }
-    setSlideOnRemove(lref) {
-        let refType = lref.refType;
-        refType = refType & ~merge_tree_1.ReferenceType.StayOnRemove;
-        refType = refType | merge_tree_1.ReferenceType.SlideOnRemove;
-        lref.refType = refType;
-    }
-    ackInterval(interval, op) {
-        // in current usage, interval is always a SequenceInterval
-        if (!(interval instanceof SequenceInterval)) {
-            return;
-        }
-        if (!(0, merge_tree_1.refTypeIncludesFlag)(interval.start, merge_tree_1.ReferenceType.StayOnRemove) &&
-            !(0, merge_tree_1.refTypeIncludesFlag)(interval.end, merge_tree_1.ReferenceType.StayOnRemove)) {
-            return;
-        }
-        const newStart = this.getSlideToSegment(interval.start);
-        const newEnd = this.getSlideToSegment(interval.end);
-        const id = interval.properties[reservedIntervalIdKey];
-        const hasPendingStartChange = this.hasPendingChangeStart(id);
-        const hasPendingEndChange = this.hasPendingChangeEnd(id);
-        if (!hasPendingStartChange) {
-            this.setSlideOnRemove(interval.start);
-        }
-        if (!hasPendingEndChange) {
-            this.setSlideOnRemove(interval.end);
-        }
-        const needsStartUpdate = newStart !== undefined && !hasPendingStartChange;
-        const needsEndUpdate = newEnd !== undefined && !hasPendingEndChange;
-        if (needsStartUpdate || needsEndUpdate) {
-            // In this case, where we change the start or end of an interval,
-            // it is necessary to remove and re-add the interval listeners.
-            // This ensures that the correct listeners are added to the ReferencePosition.
-            this.localCollection.removeExistingInterval(interval);
-            if (needsStartUpdate) {
-                const props = interval.start.properties;
-                this.client.removeLocalReferencePosition(interval.start);
-                interval.start = createPositionReferenceFromSegoff(this.client, newStart, interval.start.refType, op);
-                if (props) {
-                    interval.start.addProperties(props);
-                }
-            }
-            if (needsEndUpdate) {
-                const props = interval.end.properties;
-                this.client.removeLocalReferencePosition(interval.end);
-                interval.end = createPositionReferenceFromSegoff(this.client, newEnd, interval.end.refType, op);
-                if (props) {
-                    interval.end.addProperties(props);
-                }
-            }
-            this.localCollection.add(interval);
-        }
-    }
-    /** @deprecated - use ackAdd */
-    addInternal(serializedInterval, local, op) {
-        return this.ackAdd(serializedInterval, local, op);
-    }
-    /** @internal */
-    ackAdd(serializedInterval, local, op) {
-        var _a;
-        if (local) {
-            const id = (_a = serializedInterval.properties) === null || _a === void 0 ? void 0 : _a[reservedIntervalIdKey];
-            const localInterval = this.getIntervalById(id);
-            if (localInterval) {
-                this.ackInterval(localInterval, op);
-            }
-            return;
-        }
-        if (!this.attached) {
-            throw new telemetry_utils_1.LoggingError("attachSequence must be called");
-        }
-        this.localCollection.ensureSerializedId(serializedInterval);
-        const interval = this.localCollection.addInterval(serializedInterval.start, serializedInterval.end, serializedInterval.intervalType, serializedInterval.properties, op);
-        if (interval) {
-            if (this.onDeserialize) {
-                this.onDeserialize(interval);
-            }
-        }
-        this.emit("addInterval", interval, local, op);
-        return interval;
-    }
-    /** @deprecated - use ackDelete */
-    deleteInterval(serializedInterval, local, op) {
-        return this.ackDelete(serializedInterval, local, op);
-    }
-    /** @internal */
-    ackDelete(serializedInterval, local, op) {
-        if (local) {
-            // Local ops were applied when the message was created and there's no "pending delete"
-            // state to bookkeep: remote operation application takes into account possibility of
-            // locally deleted interval whenever a lookup happens.
-            return;
-        }
-        if (!this.attached) {
-            throw new telemetry_utils_1.LoggingError("attach must be called prior to deleting intervals");
-        }
-        const id = this.localCollection.ensureSerializedId(serializedInterval);
-        const interval = this.localCollection.getIntervalById(id);
-        if (interval) {
-            this.deleteExistingInterval(interval, local, op);
-        }
-    }
-    /**
-     * @internal
-     */
-    serializeInternal() {
-        if (!this.attached) {
-            throw new telemetry_utils_1.LoggingError("attachSequence must be called");
-        }
-        return this.localCollection.serialize();
-    }
-    [Symbol.iterator]() {
-        const iterator = new IntervalCollectionIterator(this);
-        return iterator;
-    }
-    CreateForwardIteratorWithStartPosition(startPosition) {
-        const iterator = new IntervalCollectionIterator(this, true, startPosition);
-        return iterator;
-    }
-    CreateBackwardIteratorWithStartPosition(startPosition) {
-        const iterator = new IntervalCollectionIterator(this, false, startPosition);
-        return iterator;
-    }
-    CreateForwardIteratorWithEndPosition(endPosition) {
-        const iterator = new IntervalCollectionIterator(this, true, undefined, endPosition);
-        return iterator;
-    }
-    CreateBackwardIteratorWithEndPosition(endPosition) {
-        const iterator = new IntervalCollectionIterator(this, false, undefined, endPosition);
-        return iterator;
-    }
-    gatherIterationResults(results, iteratesForward, start, end) {
-        if (!this.attached) {
-            return;
-        }
-        this.localCollection.gatherIterationResults(results, iteratesForward, start, end);
-    }
-    findOverlappingIntervals(startPosition, endPosition) {
-        if (!this.attached) {
-            throw new telemetry_utils_1.LoggingError("attachSequence must be called");
-        }
-        return this.localCollection.findOverlappingIntervals(startPosition, endPosition);
-    }
-    map(fn) {
-        if (!this.attached) {
-            throw new telemetry_utils_1.LoggingError("attachSequence must be called");
-        }
-        this.localCollection.map(fn);
-    }
-    previousInterval(pos) {
-        if (!this.attached) {
-            throw new telemetry_utils_1.LoggingError("attachSequence must be called");
-        }
-        return this.localCollection.previousInterval(pos);
-    }
-    nextInterval(pos) {
-        if (!this.attached) {
-            throw new telemetry_utils_1.LoggingError("attachSequence must be called");
-        }
-        return this.localCollection.nextInterval(pos);
-    }
-}
-exports.IntervalCollection = IntervalCollection;
-//# sourceMappingURL=intervalCollection.js.map