@fluidframework/legacy-dds 2.50.0-345060

package/dist/array/sharedArray.js

@@ -0,0 +1,652 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharedArrayClass = void 0;
+const internal_1 = require("@fluidframework/core-utils/internal");
+const internal_2 = require("@fluidframework/driver-definitions/internal");
+const internal_3 = require("@fluidframework/runtime-utils/internal");
+const internal_4 = require("@fluidframework/shared-object-base/internal");
+const uuid_1 = require("uuid");
+const sharedArrayFactory_js_1 = require("./sharedArrayFactory.js");
+const sharedArrayOperations_js_1 = require("./sharedArrayOperations.js");
+const sharedArrayRevertible_js_1 = require("./sharedArrayRevertible.js");
+const snapshotFileName = "header";
+/**
+ * Represents a shared array that allows communication between distributed clients.
+ *
+ * @internal
+ */
+class SharedArrayClass extends internal_4.SharedObject {
+    /**
+     * Create a new shared array
+     *
+     * @param runtime - data store runtime the new shared array belongs to
+     * @param id - optional name of the shared array
+     * @returns newly create shared array (but not attached yet)
+     */
+    static create(runtime, id) {
+        return runtime.createChannel(id, sharedArrayFactory_js_1.SharedArrayFactory.Type);
+    }
+    /**
+     * Get a factory for SharedArray to register with the data store.
+     *
+     * @returns a factory that creates and load SharedArray
+     */
+    static getFactory() {
+        return new sharedArrayFactory_js_1.SharedArrayFactory();
+    }
+    /**
+     * Constructs a new shared array. If the object is non-local an id and service interfaces will
+     * be provided
+     *
+     * @param id - optional name of the shared array
+     * @param runtime - data store runtime the shared array belongs to
+     * @param attributes - represents the attributes of a channel/DDS.
+     */
+    constructor(id, runtime, attributes) {
+        super(id, runtime, attributes, "loop_sharedArray_" /* telemetryContextPrefix */);
+        this.sharedArray = [];
+        this.idToEntryMap = new Map();
+    }
+    /**
+     * Method that returns the ordered list of the items held in the DDS at this point in time.
+     * Note: This is only a snapshot of the array
+     */
+    get() {
+        return this.sharedArray.filter((item) => !item.isDeleted).map((entry) => entry.value);
+    }
+    summarizeCore(serializer) {
+        // Deep copy and unset the local flags. Needed when snapshotting is happening for runtime not attached
+        const dataArrayCopy = [];
+        for (const entry of this.sharedArray) {
+            dataArrayCopy.push({
+                entryId: entry.entryId,
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                value: JSON.parse(serializer.stringify(entry.value, this.handle)),
+                isDeleted: entry.isDeleted,
+                prevEntryId: entry.prevEntryId,
+                nextEntryId: entry.nextEntryId,
+            });
+        }
+        // We are snapshotting current client data so autoacking pending local.
+        // Assumption : This should happen only for offline client creating the array. All other scenarios should
+        //              get to MSN - where there can be no local pending possible.
+        for (const entry of this.sharedArray) {
+            this.unsetLocalFlags(entry);
+        }
+        const contents = {
+            dataArray: dataArrayCopy,
+        };
+        const tree = {
+            entries: [
+                {
+                    mode: internal_2.FileMode.File,
+                    path: snapshotFileName,
+                    type: internal_2.TreeEntry[internal_2.TreeEntry.Blob],
+                    value: {
+                        contents: serializer.stringify(contents, this.handle),
+                        // eslint-disable-next-line unicorn/text-encoding-identifier-case
+                        encoding: "utf-8",
+                    },
+                },
+            ],
+        };
+        const summaryTreeWithStats = (0, internal_3.convertToSummaryTreeWithStats)(tree);
+        return summaryTreeWithStats;
+    }
+    insertBulkAfter(ref, values) {
+        let itemIndex = 0;
+        if (ref !== undefined) {
+            for (itemIndex = this.sharedArray.length - 1; itemIndex > 0; itemIndex -= 1) {
+                const item = this.sharedArray[itemIndex];
+                if (item && !item.isDeleted && item.value === ref) {
+                    break;
+                }
+            }
+            // Add one since we're inserting it after this rowId. If rowId is not found, we will get -1, which after
+            // adding one, will be 0, which will place the new rows at the right place too
+            itemIndex += 1;
+        }
+        // Insert new elements
+        for (const value of values) {
+            this.insertCore(itemIndex, value);
+            itemIndex += 1;
+        }
+    }
+    insert(index, value) {
+        if (index < 0) {
+            throw new Error("Invalid input: Insertion index provided is less than 0.");
+        }
+        this.insertCore(this.findInternalInsertionIndex(index), value);
+    }
+    insertCore(indexInternal, value) {
+        const insertAfterEntryId = indexInternal >= 1 ? this.sharedArray[indexInternal - 1]?.entryId : undefined;
+        const newEntryId = this.createAddEntry(indexInternal, value);
+        const op = {
+            type: sharedArrayOperations_js_1.OperationType.insertEntry,
+            entryId: newEntryId,
+            value,
+            insertAfterEntryId,
+        };
+        this.emitValueChangedEvent(op, true /* isLocal */);
+        this.emitRevertibleEvent(op);
+        // If we are not attached, don't submit the op.
+        if (!this.isAttached()) {
+            return;
+        }
+        this.submitLocalMessage(op);
+    }
+    delete(index) {
+        if (index < 0) {
+            throw new Error("Invalid input: Deletion index provided is less than 0.");
+        }
+        const indexInternal = this.findInternalDeletionIndex(index);
+        const entry = this.sharedArray[indexInternal];
+        (0, internal_1.assert)(entry !== undefined, 0xb90 /* Invalid index */);
+        const entryId = entry.entryId;
+        this.deleteCore(indexInternal);
+        const op = {
+            type: sharedArrayOperations_js_1.OperationType.deleteEntry,
+            entryId,
+        };
+        this.emitValueChangedEvent(op, true /* isLocal */);
+        this.emitRevertibleEvent(op);
+        // If we are not attached, don't submit the op.
+        if (!this.isAttached()) {
+            return;
+        }
+        this.submitLocalMessage(op);
+    }
+    rearrangeToFront(values) {
+        for (let toIndex = 0; toIndex < values.length; toIndex += 1) {
+            const value = values[toIndex];
+            // Can skip searching first <toIndex> indices, as they contain elements we already moved.
+            for (let fromIndex = toIndex; fromIndex < this.sharedArray.length; fromIndex += 1) {
+                const item = this.sharedArray[fromIndex];
+                (0, internal_1.assert)(item !== undefined, 0xb91 /* Invalid index */);
+                if (item.value !== value) {
+                    continue;
+                }
+                if (!item.isDeleted &&
+                    // Moving to and from the same index makes no sense, so noOp
+                    fromIndex !== toIndex &&
+                    // Moving the same entry from current location to its immediate next makes no sense so noOp
+                    toIndex !== fromIndex + 1) {
+                    this.moveCore(fromIndex, toIndex);
+                }
+                break;
+            }
+        }
+    }
+    /**
+     * Moves the DDS entry from one index to another
+     *
+     * @param fromIndex - User index of the element to be moved
+     * @param toIndex - User index to which the element should move to
+     */
+    move(fromIndex, toIndex) {
+        if (fromIndex < 0) {
+            throw new Error("Invalid input: fromIndex value provided is less than 0");
+        }
+        if (toIndex < 0) {
+            throw new Error("Invalid input: toIndex value provided is less than 0");
+        }
+        if (
+        // Moving to and from the same index makes no sense, so noOp
+        fromIndex === toIndex ||
+            // Moving the same entry from current location to its immediate next makes no sense so noOp
+            toIndex === fromIndex + 1) {
+            return;
+        }
+        const fromIndexInternal = this.findInternalDeletionIndex(fromIndex);
+        const toIndexInternal = this.findInternalInsertionIndex(toIndex);
+        this.moveCore(fromIndexInternal, toIndexInternal);
+    }
+    moveCore(fromIndexInternal, toIndexInternal) {
+        const insertAfterEntryId = toIndexInternal >= 1 ? this.sharedArray[toIndexInternal - 1]?.entryId : undefined;
+        const entryId = this.sharedArray[fromIndexInternal]?.entryId;
+        (0, internal_1.assert)(entryId !== undefined, 0xb92 /* Invalid index */);
+        const changedToEntryId = this.createMoveEntry(fromIndexInternal, toIndexInternal);
+        const op = {
+            type: sharedArrayOperations_js_1.OperationType.moveEntry,
+            entryId,
+            insertAfterEntryId,
+            changedToEntryId,
+        };
+        this.emitValueChangedEvent(op, true /* isLocal */);
+        this.emitRevertibleEvent(op);
+        // If we are not attached, don't submit the op.
+        if (!this.isAttached()) {
+            return;
+        }
+        this.submitLocalMessage(op);
+    }
+    /**
+     * Method used to do undo/redo operation for the given entry id. This method is
+     * used for undo/redo of only insert and delete operations. Move operation is NOT handled
+     * by this method
+     *
+     * @param entryId - Entry Id for which the the undo/redo operation is to be applied
+     */
+    toggle(entryId) {
+        const liveEntry = this.getLiveEntry(entryId);
+        const isDeleted = !liveEntry.isDeleted;
+        // Adding local pending counter
+        this.getEntryForId(entryId).isLocalPendingDelete += 1;
+        // Toggling the isDeleted flag to undo the last operation for the skip list payload/value
+        liveEntry.isDeleted = isDeleted;
+        const op = {
+            type: sharedArrayOperations_js_1.OperationType.toggle,
+            entryId,
+            isDeleted,
+        };
+        this.emitValueChangedEvent(op, true /* isLocal */);
+        this.emitRevertibleEvent(op);
+        // If we are not attached, don't submit the op.
+        if (!this.isAttached()) {
+            return;
+        }
+        this.submitLocalMessage(op);
+    }
+    /**
+     * Method to do undo/redo of move operation. All entries of the same payload/value are stored
+     * in the same doubly linked skip list. This skip list is updated upon every move by adding the
+     * new location as a new entry in the skip list and update the isDeleted flag to indicate the new
+     * entry is the cuurent live location for the user.
+     *
+     * @param oldEntryId - EntryId of the last live entry
+     * @param newEntryId - EntryId of the to be live entry
+     */
+    toggleMove(oldEntryId, newEntryId) {
+        if (this.getEntryForId(newEntryId).isDeleted) {
+            return;
+        }
+        // Adding local pending counter
+        this.getEntryForId(oldEntryId).isLocalPendingMove += 1;
+        this.updateLiveEntry(newEntryId, oldEntryId);
+        const op = {
+            type: sharedArrayOperations_js_1.OperationType.toggleMove,
+            entryId: oldEntryId,
+            changedToEntryId: newEntryId,
+        };
+        this.emitValueChangedEvent(op, true /* isLocal */);
+        this.emitRevertibleEvent(op);
+        // If we are not attached, don't submit the op.
+        if (!this.isAttached()) {
+            return;
+        }
+        this.submitLocalMessage(op);
+    }
+    /**
+     * Load share array from snapshot
+     *
+     * @param storage - the storage to get the snapshot from
+     * @returns - promise that resolved when the load is completed
+     */
+    async loadCore(storage) {
+        const header = await storage.readBlob(snapshotFileName);
+        // eslint-disable-next-line unicorn/text-encoding-identifier-case
+        const utf8 = new TextDecoder("utf-8").decode(header);
+        // Note: IFluidSerializer.parse() doesn't guarantee any typing; the explicit typing here is based on this code's
+        // knowledge of what it is deserializing.
+        const deserializedSharedArray = this.serializer.parse(utf8);
+        this.sharedArray = deserializedSharedArray.dataArray;
+        // Initializing the idToEntryMap optimizer data set
+        for (const entry of this.sharedArray) {
+            this.idToEntryMap.set(entry.entryId, entry);
+            this.unsetLocalFlags(entry);
+        }
+    }
+    /**
+     * Callback on disconnect
+     */
+    onDisconnect() { }
+    /**
+     * Tracks the doubly linked skip list for the given entry to identify local pending counter attribute.
+     * It signifies if a local pending operation exists for the payload/value being tracked in the skip list
+     *
+     * returns true if counterAttribute's count \> 0
+     * @param entryId - id for which counter attribute is to be tracked in chian.
+     * @param counterAttribute - flag or property name from SharedArrayEntry whose counter is to be tracked.
+     */
+    isLocalPending(entryId, counterAttribute) {
+        const getCounterAttributeValue = (entry, counterAttr) => {
+            return entry[counterAttr];
+        };
+        const inputEntry = this.getEntryForId(entryId);
+        let prevEntryId = inputEntry.prevEntryId;
+        let nextEntryId = inputEntry.nextEntryId;
+        if (getCounterAttributeValue(inputEntry, counterAttribute) > 0) {
+            return true;
+        }
+        // track back in chain
+        while (prevEntryId !== undefined && prevEntryId) {
+            const prevEntry = this.getEntryForId(prevEntryId);
+            if (getCounterAttributeValue(prevEntry, counterAttribute)) {
+                return true;
+            }
+            prevEntryId = prevEntry.prevEntryId;
+        }
+        // track forward in the chain
+        while (nextEntryId !== undefined && nextEntryId) {
+            const nextEntry = this.getEntryForId(nextEntryId);
+            if (getCounterAttributeValue(nextEntry, counterAttribute)) {
+                return true;
+            }
+            nextEntryId = nextEntry.nextEntryId;
+        }
+        return false;
+    }
+    getEntryForId(entryId) {
+        return this.idToEntryMap.get(entryId);
+    }
+    /**
+     * Process a shared array operation
+     *
+     * @param message - the message to prepare
+     * @param local - whether the message was sent by the local client
+     * @param _localOpMetadata - For local client messages, this is the metadata that was submitted with the message.
+     * For messages from a remote client, this will be undefined.
+     */
+    processCore(message, local, _localOpMetadata) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison
+        if (message.type === internal_2.MessageType.Operation) {
+            const op = message.contents;
+            const opEntry = this.getEntryForId(op.entryId);
+            switch (op.type) {
+                case sharedArrayOperations_js_1.OperationType.insertEntry: {
+                    this.handleInsertOp(op.entryId, op.insertAfterEntryId, local, op.value);
+                    break;
+                }
+                case sharedArrayOperations_js_1.OperationType.deleteEntry: {
+                    if (local) {
+                        // Decrementing local pending counter as op is already applied to local state
+                        opEntry.isLocalPendingDelete -= 1;
+                    }
+                    else {
+                        // If local pending, then ignore else apply the remote op
+                        if (!this.isLocalPending(op.entryId, "isLocalPendingDelete")) {
+                            // last element in skip list is the most recent and live entry, so marking it deleted
+                            this.getLiveEntry(op.entryId).isDeleted = true;
+                        }
+                    }
+                    break;
+                }
+                case sharedArrayOperations_js_1.OperationType.moveEntry: {
+                    this.handleInsertOp(op.changedToEntryId, op.insertAfterEntryId, local, opEntry.value);
+                    if (local) {
+                        // decrement the local pending move op as its already applied to local state
+                        opEntry.isLocalPendingMove -= 1;
+                    }
+                    else {
+                        const newElementEntryId = op.changedToEntryId;
+                        const newElement = this.getEntryForId(newElementEntryId);
+                        // If local pending then simply mark the new location dead as finally the local op will win
+                        if (this.isLocalPending(op.entryId, "isLocalPendingDelete") ||
+                            this.isLocalPending(op.entryId, "isLocalPendingMove")) {
+                            this.updateDeadEntry(op.entryId, newElementEntryId);
+                        }
+                        else {
+                            // move the element
+                            const liveEntry = this.getLiveEntry(op.entryId);
+                            const isDeleted = liveEntry.isDeleted;
+                            this.updateLiveEntry(liveEntry.entryId, newElementEntryId);
+                            // mark newly added element as deleted if existing live element was already deleted
+                            if (isDeleted) {
+                                newElement.isDeleted = isDeleted;
+                            }
+                        }
+                    }
+                    break;
+                }
+                case sharedArrayOperations_js_1.OperationType.toggle: {
+                    if (local) {
+                        // decrement the local pending delete op as its already applied to local state
+                        if (opEntry.isLocalPendingDelete) {
+                            opEntry.isLocalPendingDelete -= 1;
+                        }
+                    }
+                    else {
+                        if (!this.isLocalPending(op.entryId, "isLocalPendingDelete")) {
+                            this.getLiveEntry(op.entryId).isDeleted = op.isDeleted;
+                        }
+                    }
+                    break;
+                }
+                case sharedArrayOperations_js_1.OperationType.toggleMove: {
+                    if (local) {
+                        // decrement the local pending move op as its already applied to local state
+                        if (opEntry.isLocalPendingMove) {
+                            opEntry.isLocalPendingMove -= 1;
+                        }
+                    }
+                    else if (!this.isLocalPending(op.entryId, "isLocalPendingDelete") &&
+                        !this.isLocalPending(op.entryId, "isLocalPendingMove")) {
+                        this.updateLiveEntry(this.getLiveEntry(op.entryId).entryId, op.entryId);
+                    }
+                    break;
+                }
+                default: {
+                    throw new Error("Unknown operation");
+                }
+            }
+            if (!local) {
+                this.emitValueChangedEvent(op, local);
+            }
+        }
+    }
+    findInternalIndex(countEntries) {
+        if (countEntries < 0) {
+            throw new Error("Input count is zero");
+        }
+        let countDown = countEntries;
+        let entriesIterator = 0;
+        for (; entriesIterator < this.sharedArray.length; entriesIterator = entriesIterator + 1) {
+            const entry = this.sharedArray[entriesIterator];
+            (0, internal_1.assert)(entry !== undefined, 0xb93 /* Invalid index */);
+            if (entry.isDeleted === false) {
+                if (countDown === 0) {
+                    return entriesIterator;
+                }
+                countDown = countDown - 1;
+            }
+        }
+        throw new Error(`Count of live entries is less than required`);
+    }
+    findInternalInsertionIndex(index) {
+        return index === 0 ? index : this.findInternalIndex(index - 1) + 1;
+    }
+    findInternalDeletionIndex(index) {
+        return this.findInternalIndex(index);
+    }
+    createAddEntry(index, value) {
+        const newEntry = this.createNewEntry((0, uuid_1.v4)(), value);
+        this.addEntry(index, newEntry);
+        return newEntry.entryId;
+    }
+    addEntry(insertIndex, newEntry) {
+        // in scenario where we populate 100K rows, we insert them all at the end of array.
+        // slicing array is way slower than pushing elements.
+        if (insertIndex === this.sharedArray.length) {
+            this.sharedArray.push(newEntry);
+        }
+        else {
+            this.sharedArray.splice(insertIndex, 0 /* deleteCount */, newEntry);
+        }
+        // Updating the idToEntryMap optimizer data set as new entry has been added
+        this.idToEntryMap.set(newEntry.entryId, newEntry);
+    }
+    emitValueChangedEvent(op, isLocal) {
+        this.emit("valueChanged", op, isLocal, this);
+    }
+    emitRevertibleEvent(op) {
+        const revertible = new sharedArrayRevertible_js_1.SharedArrayRevertible(this, op);
+        this.emit("revertible", revertible);
+    }
+    deleteCore(index) {
+        const entry = this.sharedArray[index];
+        (0, internal_1.assert)(entry !== undefined, 0xb94 /* Invalid index */);
+        if (entry.isDeleted) {
+            throw new Error("Entry already deleted.");
+        }
+        entry.isDeleted = true;
+        // Adding local pending counter
+        entry.isLocalPendingDelete += 1;
+    }
+    createMoveEntry(oldIndex, newIndex) {
+        const oldEntry = this.sharedArray[oldIndex];
+        (0, internal_1.assert)(oldEntry !== undefined, 0xb95 /* Invalid index */);
+        const newEntry = this.createNewEntry((0, uuid_1.v4)(), oldEntry.value, oldEntry.entryId);
+        oldEntry.isDeleted = true;
+        oldEntry.nextEntryId = newEntry.entryId;
+        // Adding local pending counter
+        oldEntry.isLocalPendingMove += 1;
+        this.addEntry(newIndex /* insertIndex */, newEntry);
+        return newEntry.entryId;
+    }
+    /**
+     * Creates new entry of type SharedArrayEntry interface.
+     * @param entryId - id for which new entry is created
+     * @param value - value for the new entry
+     * @param prevEntryId - prevEntryId if exists to update the previous pointer of double ended linked list
+     */
+    createNewEntry(entryId, value, prevEntryId) {
+        return {
+            entryId,
+            value,
+            isAckPending: true,
+            isDeleted: false,
+            prevEntryId,
+            nextEntryId: undefined,
+            isLocalPendingDelete: 0,
+            isLocalPendingMove: 0,
+        };
+    }
+    /**
+     * Unsets all local flags used by the DDS. This method can be used after reading from snapshott to ensure
+     * local flags are initialized for use by the DDS.
+     * @param entry - Entry for which the local flags have to be cleaned up
+     */
+    unsetLocalFlags(entry) {
+        entry.isAckPending = false;
+        entry.isLocalPendingDelete = 0;
+        entry.isLocalPendingMove = 0;
+    }
+    /**
+     * Returns the index of the first entry starting with startIndex that does not have the isAckPending flag
+     */
+    getInternalInsertIndexByIgnoringLocalPendingInserts(startIndex) {
+        let localOpsIterator = startIndex;
+        for (; localOpsIterator < this.sharedArray.length; localOpsIterator = localOpsIterator + 1) {
+            const entry = this.sharedArray[localOpsIterator];
+            (0, internal_1.assert)(entry !== undefined, 0xb96 /* Invalid index */);
+            if (!entry.isAckPending) {
+                break;
+            }
+        }
+        return localOpsIterator;
+    }
+    handleInsertOp(entryId, insertAfterEntryId, local, value) {
+        let index = 0;
+        if (local) {
+            this.getEntryForId(entryId).isAckPending = false;
+        }
+        else {
+            if (insertAfterEntryId !== undefined) {
+                index = this.findIndexOfEntryId(insertAfterEntryId) + 1;
+            }
+            const newEntry = this.createNewEntry(entryId, value);
+            newEntry.isAckPending = false;
+            this.addEntry(this.getInternalInsertIndexByIgnoringLocalPendingInserts(index), newEntry);
+        }
+    }
+    findIndexOfEntryId(entryId) {
+        for (let index = 0; index < this.sharedArray.length; index = index + 1) {
+            if (this.sharedArray[index]?.entryId === entryId) {
+                return index;
+            }
+        }
+        return -1;
+    }
+    prepareToMakeEntryIdLive(entry) {
+        const prevIndex = this.findIndexOfEntryId(entry.prevEntryId);
+        const nextIndex = this.findIndexOfEntryId(entry.nextEntryId);
+        if (prevIndex !== -1) {
+            const prevEntry = this.sharedArray[prevIndex];
+            (0, internal_1.assert)(prevEntry !== undefined, 0xb97 /* Invalid index */);
+            prevEntry.nextEntryId = entry.nextEntryId;
+        }
+        if (nextIndex !== -1) {
+            const nextEntry = this.sharedArray[nextIndex];
+            (0, internal_1.assert)(nextEntry !== undefined, 0xb98 /* Invalid index */);
+            nextEntry.prevEntryId = entry.prevEntryId;
+        }
+        entry.prevEntryId = undefined;
+        entry.nextEntryId = undefined;
+    }
+    /**
+     * Method that returns the live entry.
+     * The shared array internally can store a skip list of all related entries which got created
+     * due to move operations for the same payload/value. However, all elements except for one element
+     * can have isDeleted flag as false indicating this is the live entry for the value.
+     * Current implementation ensures that the last element in the skip list of entries is the liveEntry/
+     * last live entry
+     *
+     * @param entryId - Entry id of any node in the skip list for the same payload/value
+     */
+    getLiveEntry(entryId) {
+        let liveEntry = this.getEntryForId(entryId);
+        while (liveEntry.nextEntryId !== undefined && liveEntry.nextEntryId) {
+            liveEntry = this.getEntryForId(liveEntry.nextEntryId);
+        }
+        return liveEntry;
+    }
+    /**
+     * We track sequence of moves for a entry in the shared array using doubly linked skip list.
+     * This utility function helps us keep track of the current position of an entry.value by marking the entry
+     * at previous position deleted and appending the entry at the new position at the end of the double linked
+     * list for that entry.value.
+     */
+    updateLiveEntry(oldLiveEntryEntryId, newLiveEntryEntryId) {
+        const oldLiveEntry = this.getEntryForId(oldLiveEntryEntryId);
+        const newLiveEntry = this.getEntryForId(newLiveEntryEntryId);
+        if (oldLiveEntryEntryId === newLiveEntryEntryId) {
+            oldLiveEntry.isDeleted = false;
+        }
+        else {
+            this.prepareToMakeEntryIdLive(newLiveEntry);
+            // Make entryId live
+            oldLiveEntry.nextEntryId = newLiveEntryEntryId;
+            newLiveEntry.prevEntryId = oldLiveEntryEntryId;
+            newLiveEntry.isDeleted = false;
+            oldLiveEntry.isDeleted = true;
+        }
+    }
+    /**
+     * We track sequence of moves for a entry in the shared array using doubly linked skip list.
+     * This utility function helps to insert the new entry as dead entry and reconnecting the double linked list with
+     * existingEntry -\> deadeEntry(appended) -\> existing chain(if any).
+     */
+    updateDeadEntry(existingEntryId, deadEntryId) {
+        const existingEntry = this.getEntryForId(existingEntryId);
+        const deadEntry = this.getEntryForId(deadEntryId);
+        // update dead entry's next to existingEntry's next, if existingEntry's next entry exists.
+        // It can be undefined if the exiting element is the last element (or only element) of chain.
+        if (existingEntry.nextEntryId !== undefined) {
+            deadEntry.nextEntryId = existingEntry.nextEntryId;
+            this.getEntryForId(existingEntry.nextEntryId).prevEntryId = deadEntryId;
+        }
+        // update current entry's next pointer to dead entry and vice versa.
+        existingEntry.nextEntryId = deadEntryId;
+        deadEntry.prevEntryId = existingEntryId;
+        deadEntry.isDeleted = true;
+    }
+    applyStashedOp(_content) {
+        throw new Error("Not implemented");
+    }
+}
+exports.SharedArrayClass = SharedArrayClass;
+//# sourceMappingURL=sharedArray.js.map