@fluidframework/map 1.1.0 → 1.2.0

package/lib/directory.js

@@ -68,7 +68,7 @@ DirectoryFactory.Attributes = {
  * SubDirectories can be retrieved for use as working directories.
  *
  * @example
- * ```ts
+ * ```typescript
  * mySharedDirectory.createSubDirectory("a").createSubDirectory("b").createSubDirectory("c").set("foo", val1);
  * const mySubDir = mySharedDirectory.getWorkingDirectory("/a/b/c");
  * mySubDir.get("foo"); // returns val1
@@ -364,6 +364,17 @@ export class SharedDirectory extends SharedObject {
             handler.process(op, local, localOpMetadata);
         }
     }
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.rollback}
+     * @internal
+    */
+    rollback(content, localOpMetadata) {
+        const op = content;
+        const subdir = this.getWorkingDirectory(op.path);
+        if (subdir) {
+            subdir.rollback(op, localOpMetadata);
+        }
+    }
     /**
      * Converts the given relative path to absolute against the root.
      * @param relativePath - The path to convert
@@ -399,8 +410,7 @@ export class SharedDirectory extends SharedObject {
             submit: (op, localOpMetadata) => {
                 const subdir = this.getWorkingDirectory(op.path);
                 if (subdir) {
-                    // We don't reuse the metadata but send a new one on each submit.
-                    subdir.submitClearMessage(op);
+                    subdir.resubmitClearMessage(op, localOpMetadata);
                 }
             },
         });
@@ -414,8 +424,7 @@ export class SharedDirectory extends SharedObject {
             submit: (op, localOpMetadata) => {
                 const subdir = this.getWorkingDirectory(op.path);
                 if (subdir) {
-                    // We don't reuse the metadata but send a new one on each submit.
-                    subdir.submitKeyMessage(op);
+                    subdir.resubmitKeyMessage(op, localOpMetadata);
                 }
             },
         });
@@ -430,8 +439,7 @@ export class SharedDirectory extends SharedObject {
             submit: (op, localOpMetadata) => {
                 const subdir = this.getWorkingDirectory(op.path);
                 if (subdir) {
-                    // We don't reuse the metadata but send a new one on each submit.
-                    subdir.submitKeyMessage(op);
+                    subdir.resubmitKeyMessage(op, localOpMetadata);
                 }
             },
         });
@@ -446,7 +454,7 @@ export class SharedDirectory extends SharedObject {
                 const parentSubdir = this.getWorkingDirectory(op.path);
                 if (parentSubdir) {
                     // We don't reuse the metadata but send a new one on each submit.
-                    parentSubdir.submitSubDirectoryMessage(op);
+                    parentSubdir.resubmitSubDirectoryMessage(op, localOpMetadata);
                 }
             },
         });
@@ -461,7 +469,7 @@ export class SharedDirectory extends SharedObject {
                 const parentSubdir = this.getWorkingDirectory(op.path);
                 if (parentSubdir) {
                     // We don't reuse the metadata but send a new one on each submit.
-                    parentSubdir.submitSubDirectoryMessage(op);
+                    parentSubdir.resubmitSubDirectoryMessage(op, localOpMetadata);
                 }
             },
         });
@@ -529,6 +537,24 @@ export class SharedDirectory extends SharedObject {
         return builder.getSummaryTree();
     }
 }
+function isKeyEditLocalOpMetadata(metadata) {
+    return metadata !== undefined && typeof metadata.pendingMessageId === "number" && metadata.type === "edit";
+}
+function isClearLocalOpMetadata(metadata) {
+    return metadata !== undefined && metadata.type === "clear" && typeof metadata.pendingMessageId === "number" &&
+        typeof metadata.previousStorage === "object";
+}
+function isSubDirLocalOpMetadata(metadata) {
+    return metadata !== undefined && typeof metadata.pendingMessageId === "number" &&
+        ((metadata.type === "createSubDir" && typeof metadata.previouslyExisted === "boolean") ||
+            metadata.type === "deleteSubDir");
+}
+function isDirectoryLocalOpMetadata(metadata) {
+    return metadata !== undefined && typeof metadata.pendingMessageId === "number" &&
+        (metadata.type === "edit" || metadata.type === "deleteSubDir" ||
+            (metadata.type === "clear" && typeof metadata.previousStorage === "object") ||
+            (metadata.type === "createSubDir" && typeof metadata.previouslyExisted === "boolean"));
+}
 /**
  * Node of the directory tree.
  * @sealed
@@ -548,9 +574,9 @@ class SubDirectory extends TypedEventEmitter {
         this.serializer = serializer;
         this.absolutePath = absolutePath;
         /**
-         * Tells if the sub directory is disposed or not.
+         * Tells if the sub directory is deleted or not.
          */
-        this._disposed = false;
+        this._deleted = false;
         /**
          * String representation for the class.
          */
@@ -576,20 +602,25 @@ class SubDirectory extends TypedEventEmitter {
          */
         this.pendingMessageId = -1;
         /**
-         * If a clear has been performed locally but not yet ack'd from the server, then this stores the pending id
-         * of that clear operation. Otherwise, is -1.
+         * The pending ids of any clears that have been performed locally but not yet ack'd from the server
          */
-        this.pendingClearMessageId = -1;
+        this.pendingClearMessageIds = [];
     }
     dispose(error) {
-        this._disposed = true;
+        this._deleted = true;
         this.emit("disposed", this);
     }
+    /**
+     * Unmark the deleted property when rolling back delete.
+     */
+    undispose() {
+        this._deleted = false;
+    }
     get disposed() {
-        return this._disposed;
+        return this._deleted;
     }
     throwIfDisposed() {
-        if (this._disposed) {
+        if (this._deleted) {
             throw new UsageError("Cannot access Disposed subDirectory");
         }
     }
@@ -623,7 +654,7 @@ class SubDirectory extends TypedEventEmitter {
         const localValue = this.directory.localValueMaker.fromInMemory(value);
         const serializableValue = makeSerializable(localValue, this.serializer, this.directory.handle);
         // Set the value locally.
-        this.setCore(key, localValue, true);
+        const previousValue = this.setCore(key, localValue, true);
         // If we are not attached, don't submit the op.
         if (!this.directory.isAttached()) {
             return this;
@@ -634,7 +665,7 @@ class SubDirectory extends TypedEventEmitter {
             type: "set",
             value: serializableValue,
         };
-        this.submitKeyMessage(op);
+        this.submitKeyMessage(op, previousValue);
         return this;
     }
     /**
@@ -656,7 +687,7 @@ class SubDirectory extends TypedEventEmitter {
             throw new Error(`SubDirectory name may not contain ${posix.sep}`);
         }
         // Create the sub directory locally first.
-        this.createSubDirectoryCore(subdirName, true);
+        const isNew = this.createSubDirectoryCore(subdirName, true);
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         const subDir = this._subdirectories.get(subdirName);
         // If we are not attached, don't submit the op.
@@ -668,7 +699,7 @@ class SubDirectory extends TypedEventEmitter {
             subdirName,
             type: "createSubDirectory",
         };
-        this.submitSubDirectoryMessage(op);
+        this.submitCreateSubDirectoryMessage(op, !isNew);
         return subDir;
     }
     /**
@@ -691,18 +722,18 @@ class SubDirectory extends TypedEventEmitter {
     deleteSubDirectory(subdirName) {
         this.throwIfDisposed();
         // Delete the sub directory locally first.
-        const successfullyRemoved = this.deleteSubDirectoryCore(subdirName, true);
+        const subDir = this.deleteSubDirectoryCore(subdirName, true);
         // If we are not attached, don't submit the op.
         if (!this.directory.isAttached()) {
-            return successfullyRemoved;
+            return subDir !== undefined;
         }
         const op = {
             path: this.absolutePath,
             subdirName,
             type: "deleteSubDirectory",
         };
-        this.submitSubDirectoryMessage(op);
-        return successfullyRemoved;
+        this.submitDeleteSubDirectoryMessage(op, subDir);
+        return subDir !== undefined;
     }
     /**
      * {@inheritDoc IDirectory.subdirectories}
@@ -726,35 +757,36 @@ class SubDirectory extends TypedEventEmitter {
     delete(key) {
         this.throwIfDisposed();
         // Delete the key locally first.
-        const successfullyRemoved = this.deleteCore(key, true);
+        const previousValue = this.deleteCore(key, true);
         // If we are not attached, don't submit the op.
         if (!this.directory.isAttached()) {
-            return successfullyRemoved;
+            return previousValue !== undefined;
         }
         const op = {
             key,
             path: this.absolutePath,
             type: "delete",
         };
-        this.submitKeyMessage(op);
-        return successfullyRemoved;
+        this.submitKeyMessage(op, previousValue);
+        return previousValue !== undefined;
     }
     /**
      * Deletes all keys from within this IDirectory.
      */
     clear() {
         this.throwIfDisposed();
-        // Clear the data locally first.
-        this.clearCore(true);
         // If we are not attached, don't submit the op.
         if (!this.directory.isAttached()) {
+            this.clearCore(true);
             return;
         }
+        const copy = new Map(this._storage);
+        this.clearCore(true);
         const op = {
             path: this.absolutePath,
             type: "clear",
         };
-        this.submitClearMessage(op);
+        this.submitClearMessage(op, copy);
     }
     /**
      * Issue a callback on each entry under this IDirectory.
@@ -849,15 +881,12 @@ class SubDirectory extends TypedEventEmitter {
     processClearMessage(op, local, localOpMetadata) {
         this.throwIfDisposed();
         if (local) {
-            assert(localOpMetadata !== undefined, 0x00f /* pendingMessageId is missing from the local client's operation */);
-            const pendingMessageId = localOpMetadata;
-            if (this.pendingClearMessageId === pendingMessageId) {
-                this.pendingClearMessageId = -1;
-            }
+            assert(isClearLocalOpMetadata(localOpMetadata), 0x00f /* `pendingMessageId is missing from the local client's ${op.type} operation` */);
+            const pendingClearMessageId = this.pendingClearMessageIds.shift();
+            assert(pendingClearMessageId === localOpMetadata.pendingMessageId, 0x32a /* pendingMessageId does not match */);
             return;
         }
         this.clearExceptPendingKeys();
-        this.directory.emit("clear", local, this.directory);
     }
     /**
      * Process a delete operation.
@@ -905,7 +934,7 @@ class SubDirectory extends TypedEventEmitter {
      */
     processCreateSubDirectoryMessage(op, local, localOpMetadata) {
         this.throwIfDisposed();
-        if (!this.needProcessSubDirectoryOperations(op, local, localOpMetadata)) {
+        if (!this.needProcessSubDirectoryOperation(op, local, localOpMetadata)) {
             return;
         }
         this.createSubDirectoryCore(op.subdirName, local);
@@ -921,7 +950,7 @@ class SubDirectory extends TypedEventEmitter {
      */
     processDeleteSubDirectoryMessage(op, local, localOpMetadata) {
         this.throwIfDisposed();
-        if (!this.needProcessSubDirectoryOperations(op, local, localOpMetadata)) {
+        if (!this.needProcessSubDirectoryOperation(op, local, localOpMetadata)) {
             return;
         }
         this.deleteSubDirectoryCore(op.subdirName, local);
@@ -929,35 +958,139 @@ class SubDirectory extends TypedEventEmitter {
     /**
      * Submit a clear operation.
      * @param op - The operation
-     * @internal
      */
-    submitClearMessage(op) {
+    submitClearMessage(op, previousValue) {
         this.throwIfDisposed();
+        const pendingMsgId = ++this.pendingMessageId;
+        this.pendingClearMessageIds.push(pendingMsgId);
+        const metadata = {
+            type: "clear",
+            pendingMessageId: pendingMsgId,
+            previousStorage: previousValue,
+        };
+        this.directory.submitDirectoryMessage(op, metadata);
+    }
+    /**
+     * Resubmit a clear operation.
+     * @param op - The operation
+     * @internal
+     */
+    resubmitClearMessage(op, localOpMetadata) {
+        assert(isClearLocalOpMetadata(localOpMetadata), 0x32b /* Invalid localOpMetadata for clear */);
+        // We don't reuse the metadata pendingMessageId but send a new one on each submit.
+        const pendingClearMessageId = this.pendingClearMessageIds.shift();
+        assert(pendingClearMessageId === localOpMetadata.pendingMessageId, 0x32c /* pendingMessageId does not match */);
+        this.submitClearMessage(op, localOpMetadata.previousStorage);
+    }
+    /**
+     * Get a new pending message id for the op and cache it to track the pending op
+     */
+    getKeyMessageId(op) {
+        // We don't reuse the metadata pendingMessageId but send a new one on each submit.
         const pendingMessageId = ++this.pendingMessageId;
-        this.directory.submitDirectoryMessage(op, pendingMessageId);
-        this.pendingClearMessageId = pendingMessageId;
+        const pendingMessageIds = this.pendingKeys.get(op.key);
+        if (pendingMessageIds !== undefined) {
+            pendingMessageIds.push(pendingMessageId);
+        }
+        else {
+            this.pendingKeys.set(op.key, [pendingMessageId]);
+        }
+        return pendingMessageId;
     }
     /**
      * Submit a key operation.
      * @param op - The operation
+     * @param previousValue - The value of the key before this op
+     */
+    submitKeyMessage(op, previousValue) {
+        this.throwIfDisposed();
+        const pendingMessageId = this.getKeyMessageId(op);
+        const localMetadata = { type: "edit", pendingMessageId, previousValue };
+        this.directory.submitDirectoryMessage(op, localMetadata);
+    }
+    /**
+     * Submit a key message to remote clients based on a previous submit.
+     * @param op - The map key message
+     * @param localOpMetadata - Metadata from the previous submit
      * @internal
      */
-    submitKeyMessage(op) {
+    resubmitKeyMessage(op, localOpMetadata) {
+        assert(isKeyEditLocalOpMetadata(localOpMetadata), 0x32d /* Invalid localOpMetadata in submit */);
+        // clear the old pending message id
+        const pendingMessageIds = this.pendingKeys.get(op.key);
+        assert(pendingMessageIds !== undefined && pendingMessageIds[0] === localOpMetadata.pendingMessageId, 0x32e /* Unexpected pending message received */);
+        pendingMessageIds.shift();
+        if (pendingMessageIds.length === 0) {
+            this.pendingKeys.delete(op.key);
+        }
+        this.submitKeyMessage(op, localOpMetadata.previousValue);
+    }
+    /**
+     * Get a new pending message id for the op and cache it to track the pending op
+     */
+    getSubDirMessageId(op) {
+        // We don't reuse the metadata pendingMessageId but send a new one on each submit.
+        const newMessageId = ++this.pendingMessageId;
+        const pendingMessageIds = this.pendingSubDirectories.get(op.subdirName);
+        if (pendingMessageIds !== undefined) {
+            pendingMessageIds.push(newMessageId);
+        }
+        else {
+            this.pendingSubDirectories.set(op.subdirName, [newMessageId]);
+        }
+        return newMessageId;
+    }
+    /**
+     * Submit a create subdirectory operation.
+     * @param op - The operation
+     * @param prevExisted - Whether the subdirectory existed before the op
+     */
+    submitCreateSubDirectoryMessage(op, prevExisted) {
         this.throwIfDisposed();
-        const pendingMessageId = ++this.pendingMessageId;
-        this.directory.submitDirectoryMessage(op, pendingMessageId);
-        this.pendingKeys.set(op.key, pendingMessageId);
+        const newMessageId = this.getSubDirMessageId(op);
+        const localOpMetadata = {
+            type: "createSubDir",
+            pendingMessageId: newMessageId,
+            previouslyExisted: prevExisted,
+        };
+        this.directory.submitDirectoryMessage(op, localOpMetadata);
     }
     /**
-     * Submit a subdirectory operation.
+     * Submit a delete subdirectory operation.
      * @param op - The operation
-     * @internal
+     * @param subDir - Any subdirectory deleted by the op
      */
-    submitSubDirectoryMessage(op) {
+    submitDeleteSubDirectoryMessage(op, subDir) {
         this.throwIfDisposed();
-        const pendingMessageId = ++this.pendingMessageId;
-        this.directory.submitDirectoryMessage(op, pendingMessageId);
-        this.pendingSubDirectories.set(op.subdirName, pendingMessageId);
+        const newMessageId = this.getSubDirMessageId(op);
+        const localOpMetadata = {
+            type: "deleteSubDir",
+            pendingMessageId: newMessageId,
+            subDirectory: subDir,
+        };
+        this.directory.submitDirectoryMessage(op, localOpMetadata);
+    }
+    /**
+     * Submit a subdirectory operation again
+     * @param op - The operation
+     * @param localOpMetadata - metadata submitted with the op originally
+     * @internal
+     */
+    resubmitSubDirectoryMessage(op, localOpMetadata) {
+        assert(isSubDirLocalOpMetadata(localOpMetadata), 0x32f /* Invalid localOpMetadata for sub directory op */);
+        // clear the old pending message id
+        const pendingMessageIds = this.pendingSubDirectories.get(op.subdirName);
+        assert(pendingMessageIds !== undefined && pendingMessageIds[0] === localOpMetadata.pendingMessageId, 0x330 /* Unexpected pending message received */);
+        pendingMessageIds.shift();
+        if (pendingMessageIds.length === 0) {
+            this.pendingSubDirectories.delete(op.subdirName);
+        }
+        if (localOpMetadata.type === "createSubDir") {
+            this.submitCreateSubDirectoryMessage(op, localOpMetadata.previouslyExisted);
+        }
+        else {
+            this.submitDeleteSubDirectoryMessage(op, localOpMetadata.subDirectory);
+        }
     }
     /**
      * Get the storage of this subdirectory in a serializable format, to be used in snapshotting.
@@ -1004,6 +1137,67 @@ class SubDirectory extends TypedEventEmitter {
         this.throwIfDisposed();
         return this._storage.get(key);
     }
+    /**
+     * Remove the pendingMessageId from the map tracking it on rollback
+     * @param map - map tracking the pending messages
+     * @param key - key of the edit in the op
+     */
+    rollbackPendingMessageId(map, key, pendingMessageId) {
+        const pendingMessageIds = map.get(key);
+        const lastPendingMessageId = pendingMessageIds === null || pendingMessageIds === void 0 ? void 0 : pendingMessageIds.pop();
+        if (!pendingMessageIds || lastPendingMessageId !== pendingMessageId) {
+            throw new Error("Rollback op does not match last pending");
+        }
+        if (pendingMessageIds.length === 0) {
+            map.delete(key);
+        }
+    }
+    /**
+     * Rollback a local op
+     * @param op - The operation to rollback
+     * @param localOpMetadata - The local metadata associated with the op.
+     */
+    rollback(op, localOpMetadata) {
+        if (!isDirectoryLocalOpMetadata(localOpMetadata)) {
+            throw new Error("Invalid localOpMetadata");
+        }
+        if (op.type === "clear" && localOpMetadata.type === "clear") {
+            localOpMetadata.previousStorage.forEach((localValue, key) => {
+                this.setCore(key, localValue, true);
+            });
+            const lastPendingClearId = this.pendingClearMessageIds.pop();
+            if (lastPendingClearId === undefined || lastPendingClearId !== localOpMetadata.pendingMessageId) {
+                throw new Error("Rollback op does match last clear");
+            }
+        }
+        else if ((op.type === "delete" || op.type === "set") && localOpMetadata.type === "edit") {
+            if (localOpMetadata.previousValue === undefined) {
+                this.deleteCore(op.key, true);
+            }
+            else {
+                this.setCore(op.key, localOpMetadata.previousValue, true);
+            }
+            this.rollbackPendingMessageId(this.pendingKeys, op.key, localOpMetadata.pendingMessageId);
+        }
+        else if (op.type === "createSubDirectory" && localOpMetadata.type === "createSubDir") {
+            if (!localOpMetadata.previouslyExisted) {
+                this.deleteSubDirectoryCore(op.subdirName, true);
+            }
+            this.rollbackPendingMessageId(this.pendingSubDirectories, op.subdirName, localOpMetadata.pendingMessageId);
+        }
+        else if (op.type === "deleteSubDirectory" && localOpMetadata.type === "deleteSubDir") {
+            if (localOpMetadata.subDirectory !== undefined) {
+                this.undeleteSubDirectoryTree(localOpMetadata.subDirectory);
+                // don't need to register events because deleting never unregistered
+                this._subdirectories.set(op.subdirName, localOpMetadata.subDirectory);
+                this.emit("subDirectoryCreated", op.subdirName, true, this);
+            }
+            this.rollbackPendingMessageId(this.pendingSubDirectories, op.subdirName, localOpMetadata.pendingMessageId);
+        }
+        else {
+            throw new Error("Unsupported op for rollback");
+        }
+    }
     /**
      * Converts the given relative path into an absolute path.
      * @param path - Relative path to convert
@@ -1016,16 +1210,16 @@ class SubDirectory extends TypedEventEmitter {
      * If our local operations that have not yet been ack'd will eventually overwrite an incoming operation, we should
      * not process the incoming operation.
      * @param op - Operation to check
-     * @param local - Whether the message originated from the local client
-     * @param message - The message
-     * @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.
+     * @param local - Whether the operation originated from the local client
+     * @param localOpMetadata - For local client ops, this is the metadata that was submitted with the op.
+     * For ops from a remote client, this will be undefined.
      * @returns True if the operation should be processed, false otherwise
      */
     needProcessStorageOperation(op, local, localOpMetadata) {
-        if (this.pendingClearMessageId !== -1) {
+        if (this.pendingClearMessageIds.length > 0) {
             if (local) {
-                assert(localOpMetadata !== undefined && localOpMetadata < this.pendingClearMessageId, 0x010 /* "Received out of order storage op when there is an unackd clear message" */);
+                assert(localOpMetadata !== undefined && isKeyEditLocalOpMetadata(localOpMetadata) &&
+                    localOpMetadata.pendingMessageId < this.pendingClearMessageIds[0], 0x010 /* "Received out of order storage op when there is an unackd clear message" */);
             }
             // If I have a NACK clear, we can ignore all ops.
             return false;
@@ -1035,9 +1229,11 @@ class SubDirectory extends TypedEventEmitter {
             // Found an NACK op, clear it from the directory if the latest sequence number in the directory
             // match the message's and don't process the op.
             if (local) {
-                assert(localOpMetadata !== undefined, 0x011 /* pendingMessageId is missing from the local client's operation */);
-                const pendingMessageId = localOpMetadata;
-                if (pendingKeyMessageId === pendingMessageId) {
+                assert(localOpMetadata !== undefined && isKeyEditLocalOpMetadata(localOpMetadata), 0x011 /* pendingMessageId is missing from the local client's operation */);
+                const pendingMessageIds = this.pendingKeys.get(op.key);
+                assert(pendingMessageIds !== undefined && pendingMessageIds[0] === localOpMetadata.pendingMessageId, 0x331 /* Unexpected pending message received */);
+                pendingMessageIds.shift();
+                if (pendingMessageIds.length === 0) {
                     this.pendingKeys.delete(op.key);
                 }
             }
@@ -1056,13 +1252,15 @@ class SubDirectory extends TypedEventEmitter {
      * For messages from a remote client, this will be undefined.
      * @returns True if the operation should be processed, false otherwise
      */
-    needProcessSubDirectoryOperations(op, local, localOpMetadata) {
+    needProcessSubDirectoryOperation(op, local, localOpMetadata) {
         const pendingSubDirectoryMessageId = this.pendingSubDirectories.get(op.subdirName);
         if (pendingSubDirectoryMessageId !== undefined) {
             if (local) {
-                assert(localOpMetadata !== undefined, 0x012 /* pendingMessageId is missing from the local client's operation */);
-                const pendingMessageId = localOpMetadata;
-                if (pendingSubDirectoryMessageId === pendingMessageId) {
+                assert(isSubDirLocalOpMetadata(localOpMetadata), 0x012 /* pendingMessageId is missing from the local client's operation */);
+                const pendingMessageIds = this.pendingSubDirectories.get(op.subdirName);
+                assert(pendingMessageIds !== undefined && pendingMessageIds[0] === localOpMetadata.pendingMessageId, 0x332 /* Unexpected pending message received */);
+                pendingMessageIds.shift();
+                if (pendingMessageIds.length === 0) {
                     this.pendingSubDirectories.delete(op.subdirName);
                 }
             }
@@ -1081,9 +1279,9 @@ class SubDirectory extends TypedEventEmitter {
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             temp.set(key, this._storage.get(key));
         });
-        this._storage.clear();
+        this.clearCore(false);
         temp.forEach((value, key, map) => {
-            this._storage.set(key, value);
+            this.setCore(key, value, true);
         });
     }
     /**
@@ -1099,11 +1297,11 @@ class SubDirectory extends TypedEventEmitter {
      * Delete implementation used for both locally sourced deletes as well as incoming remote deletes.
      * @param key - The key being deleted
      * @param local - Whether the message originated from the local client
-     * @param op - The message if from a remote delete, or null if from a local delete
-     * @returns True if the key existed and was deleted, false if it did not exist
+     * @returns Previous local value of the key if it existed, undefined if it did not exist
      */
     deleteCore(key, local) {
-        const previousValue = this.get(key);
+        const previousLocalValue = this._storage.get(key);
+        const previousValue = previousLocalValue === null || previousLocalValue === void 0 ? void 0 : previousLocalValue.value;
         const successfullyRemoved = this._storage.delete(key);
         if (successfullyRemoved) {
             const event = { key, path: this.absolutePath, previousValue };
@@ -1111,27 +1309,30 @@ class SubDirectory extends TypedEventEmitter {
             const containedEvent = { key, previousValue };
             this.emit("containedValueChanged", containedEvent, local, this);
         }
-        return successfullyRemoved;
+        return previousLocalValue;
     }
     /**
      * Set implementation used for both locally sourced sets as well as incoming remote sets.
      * @param key - The key being set
      * @param value - The value being set
      * @param local - Whether the message originated from the local client
-     * @param op - The message if from a remote set, or null if from a local set
+     * @returns Previous local value of the key, if any
      */
     setCore(key, value, local) {
-        const previousValue = this.get(key);
+        const previousLocalValue = this._storage.get(key);
+        const previousValue = previousLocalValue === null || previousLocalValue === void 0 ? void 0 : previousLocalValue.value;
         this._storage.set(key, value);
         const event = { key, path: this.absolutePath, previousValue };
         this.directory.emit("valueChanged", event, local, this.directory);
         const containedEvent = { key, previousValue };
         this.emit("containedValueChanged", containedEvent, local, this);
+        return previousLocalValue;
     }
     /**
      * Create subdirectory implementation used for both locally sourced creation as well as incoming remote creation.
      * @param subdirName - The name of the subdirectory being created
      * @param local - Whether the message originated from the local client
+     * @returns - True if is newly created, false if it already existed.
      */
     createSubDirectoryCore(subdirName, local) {
         if (!this._subdirectories.has(subdirName)) {
@@ -1140,7 +1341,9 @@ class SubDirectory extends TypedEventEmitter {
             this.registerEventsOnSubDirectory(subDir, subdirName);
             this._subdirectories.set(subdirName, subDir);
             this.emit("subDirectoryCreated", subdirName, local, this);
+            return true;
         }
+        return false;
     }
     registerEventsOnSubDirectory(subDirectory, subDirName) {
         subDirectory.on("subDirectoryCreated", (relativePath, local) => {
@@ -1154,18 +1357,17 @@ class SubDirectory extends TypedEventEmitter {
      * Delete subdirectory implementation used for both locally sourced creation as well as incoming remote creation.
      * @param subdirName - The name of the subdirectory being deleted
      * @param local - Whether the message originated from the local client
-     * @param op - The message if from a remote delete, or null if from a local delete
      */
     deleteSubDirectoryCore(subdirName, local) {
-        const previousValue = this.getSubDirectory(subdirName);
+        const previousValue = this._subdirectories.get(subdirName);
         // This should make the subdirectory structure unreachable so it can be GC'd and won't appear in snapshots
-        // Might want to consider cleaning out the structure more exhaustively though?
-        const successfullyRemoved = this._subdirectories.delete(subdirName);
+        // Might want to consider cleaning out the structure more exhaustively though? But not when rollback.
         if (previousValue !== undefined) {
+            this._subdirectories.delete(subdirName);
             this.disposeSubDirectoryTree(previousValue);
             this.emit("subDirectoryDeleted", subdirName, local, this);
         }
-        return successfullyRemoved;
+        return previousValue;
     }
     disposeSubDirectoryTree(directory) {
         if (!directory) {
@@ -1180,5 +1382,12 @@ class SubDirectory extends TypedEventEmitter {
             directory.dispose();
         }
     }
+    undeleteSubDirectoryTree(directory) {
+        // Restore deleted subdirectory tree. This will unmark "deleted" from the subdirectories from bottom to top.
+        for (const [_, subDirectory] of this._subdirectories.entries()) {
+            this.undeleteSubDirectoryTree(subDirectory);
+        }
+        directory.undispose();
+    }
 }
 //# sourceMappingURL=directory.js.map