@fluidframework/map 2.0.0-dev.2.3.0.115467 → 2.0.0-dev.4.1.0.148229

package/lib/directory.js

@@ -6,11 +6,11 @@ var _a, _b;
 import { assert, TypedEventEmitter } from "@fluidframework/common-utils";
 import { UsageError } from "@fluidframework/container-utils";
 import { readAndParse } from "@fluidframework/driver-utils";
-import { MessageType, } from "@fluidframework/protocol-definitions";
+import { MessageType } from "@fluidframework/protocol-definitions";
 import { SharedObject, ValueType } from "@fluidframework/shared-object-base";
 import { SummaryTreeBuilder } from "@fluidframework/runtime-utils";
 import * as path from "path-browserify";
-import { LocalValueMaker, makeSerializable, } from "./localValues";
+import { LocalValueMaker, makeSerializable } from "./localValues";
 import { pkgVersion } from "./packageVersion";
 // We use path-browserify since this code can run safely on the server or the browser.
 // We standardize on using posix slashes everywhere.
@@ -92,7 +92,7 @@ export class SharedDirectory extends SharedObject {
         /**
          * Root of the SharedDirectory, most operations on the SharedDirectory itself act on the root.
          */
-        this.root = new SubDirectory(this, this.runtime, this.serializer, posix.sep);
+        this.root = new SubDirectory(0, new Set(), this, this.runtime, this.serializer, posix.sep);
         /**
          * Mapping of op types to message handlers.
          */
@@ -137,6 +137,8 @@ export class SharedDirectory extends SharedObject {
     /**
      * {@inheritDoc IDirectory.get}
      */
+    // TODO: Use `unknown` instead (breaking change).
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     get(key) {
         return this.root.get(key);
     }
@@ -185,13 +187,18 @@ export class SharedDirectory extends SharedObject {
      * Issue a callback on each entry under this IDirectory.
      * @param callback - Callback to issue
      */
+    // TODO: Use `unknown` instead (breaking change).
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     forEach(callback) {
+        // eslint-disable-next-line unicorn/no-array-for-each, unicorn/no-array-callback-reference
         this.root.forEach(callback);
     }
     /**
      * Get an iterator over the entries under this IDirectory.
      * @returns The iterator
      */
+    // TODO: Use `unknown` instead (breaking change).
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     [(_a = Symbol.toStringTag, Symbol.iterator)]() {
         return this.root[Symbol.iterator]();
     }
@@ -199,6 +206,8 @@ export class SharedDirectory extends SharedObject {
      * Get an iterator over the entries under this IDirectory.
      * @returns The iterator
      */
+    // TODO: Use `unknown` instead (breaking change).
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     entries() {
         return this.root.entries();
     }
@@ -219,6 +228,8 @@ export class SharedDirectory extends SharedObject {
      * Get an iterator over the values under this IDirectory.
      * @returns The iterator
      */
+    // TODO: Use `unknown` instead (breaking change).
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     values() {
         return this.root.values();
     }
@@ -261,7 +272,7 @@ export class SharedDirectory extends SharedObject {
             return this.root;
         }
         let currentSubDir = this.root;
-        const subdirs = absolutePath.substr(1).split(posix.sep);
+        const subdirs = absolutePath.slice(1).split(posix.sep);
         for (const subdir of subdirs) {
             currentSubDir = currentSubDir.getSubDirectory(subdir);
             if (!currentSubDir) {
@@ -337,7 +348,10 @@ export class SharedDirectory extends SharedObject {
                 for (const [subdirName, subdirObject] of Object.entries(currentSubDirObject.subdirectories)) {
                     let newSubDir = currentSubDir.getSubDirectory(subdirName);
                     if (!newSubDir) {
-                        newSubDir = new SubDirectory(this, this.runtime, this.serializer, posix.join(currentSubDir.absolutePath, subdirName));
+                        const createInfo = subdirObject.ci;
+                        newSubDir = new SubDirectory(createInfo !== undefined ? createInfo.csn : 0, createInfo !== undefined
+                            ? new Set(createInfo.ccIds)
+                            : new Set(), this, this.runtime, this.serializer, posix.join(currentSubDir.absolutePath, subdirName));
                         currentSubDir.populateSubDirectory(subdirName, newSubDir);
                     }
                     stack.push([newSubDir, subdirObject]);
@@ -360,13 +374,13 @@ export class SharedDirectory extends SharedObject {
             const op = message.contents;
             const handler = this.messageHandlers.get(op.type);
             assert(handler !== undefined, 0x00e /* Missing message handler for message type */);
-            handler.process(op, local, localOpMetadata);
+            handler.process(message, op, local, localOpMetadata);
         }
     }
     /**
      * {@inheritDoc @fluidframework/shared-object-base#SharedObject.rollback}
      * @internal
-    */
+     */
     rollback(content, localOpMetadata) {
         const op = content;
         const subdir = this.getWorkingDirectory(op.path);
@@ -392,18 +406,45 @@ export class SharedDirectory extends SharedObject {
      * @returns The local value that was produced
      */
     makeLocal(key, absolutePath, serializable) {
-        assert(serializable.type === ValueType[ValueType.Plain] || serializable.type === ValueType[ValueType.Shared], 0x1e4 /* "Unexpected serializable type" */);
+        assert(serializable.type === ValueType[ValueType.Plain] ||
+            serializable.type === ValueType[ValueType.Shared], 0x1e4 /* "Unexpected serializable type" */);
         return this.localValueMaker.fromSerializable(serializable);
     }
+    /**
+     * This checks if there is pending delete op for local delete for a subdirectory.
+     * @param relativePath - path of sub directory.
+     * @returns - true if there is pending delete.
+     */
+    isSubDirectoryDeletePending(relativePath) {
+        const parentSubDir = this.getParentDirectory(relativePath);
+        const index = relativePath.lastIndexOf(posix.sep);
+        const dirName = relativePath.substring(index + 1);
+        return !!(parentSubDir === null || parentSubDir === void 0 ? void 0 : parentSubDir.isSubDirectoryDeletePending(dirName));
+    }
+    /**
+     * Gets the parent directory of a sub directory.
+     * @param relativePath - path of sub directory of which parent needs to be find out.
+     */
+    getParentDirectory(relativePath) {
+        const absolutePath = this.makeAbsolute(relativePath);
+        if (absolutePath === posix.sep) {
+            return undefined;
+        }
+        const index = absolutePath.lastIndexOf(posix.sep);
+        const parentAbsPath = absolutePath.substring(0, index);
+        return this.getWorkingDirectory(parentAbsPath);
+    }
     /**
      * Set the message handlers for the directory.
      */
     setMessageHandlers() {
         this.messageHandlers.set("clear", {
-            process: (op, local, localOpMetadata) => {
+            process: (msg, op, local, localOpMetadata) => {
                 const subdir = this.getWorkingDirectory(op.path);
-                if (subdir) {
-                    subdir.processClearMessage(op, local, localOpMetadata);
+                // If there is pending delete op for this subDirectory, then don't apply the this op as we are going
+                // to delete this subDirectory.
+                if (subdir && !this.isSubDirectoryDeletePending(op.path)) {
+                    subdir.processClearMessage(msg, op, local, localOpMetadata);
                 }
             },
             submit: (op, localOpMetadata) => {
@@ -420,10 +461,12 @@ export class SharedDirectory extends SharedObject {
             },
         });
         this.messageHandlers.set("delete", {
-            process: (op, local, localOpMetadata) => {
+            process: (msg, op, local, localOpMetadata) => {
                 const subdir = this.getWorkingDirectory(op.path);
-                if (subdir) {
-                    subdir.processDeleteMessage(op, local, localOpMetadata);
+                // If there is pending delete op for this subDirectory, then don't apply the this op as we are going
+                // to delete this subDirectory.
+                if (subdir && !this.isSubDirectoryDeletePending(op.path)) {
+                    subdir.processDeleteMessage(msg, op, local, localOpMetadata);
                 }
             },
             submit: (op, localOpMetadata) => {
@@ -440,11 +483,13 @@ export class SharedDirectory extends SharedObject {
             },
         });
         this.messageHandlers.set("set", {
-            process: (op, local, localOpMetadata) => {
+            process: (msg, op, local, localOpMetadata) => {
                 const subdir = this.getWorkingDirectory(op.path);
-                if (subdir) {
+                // If there is pending delete op for this subDirectory, then don't apply the this op as we are going
+                // to delete this subDirectory.
+                if (subdir && !this.isSubDirectoryDeletePending(op.path)) {
                     const context = local ? undefined : this.makeLocal(op.key, op.path, op.value);
-                    subdir.processSetMessage(op, context, local, localOpMetadata);
+                    subdir.processSetMessage(msg, op, context, local, localOpMetadata);
                 }
             },
             submit: (op, localOpMetadata) => {
@@ -462,10 +507,10 @@ export class SharedDirectory extends SharedObject {
             },
         });
         this.messageHandlers.set("createSubDirectory", {
-            process: (op, local, localOpMetadata) => {
+            process: (msg, op, local, localOpMetadata) => {
                 const parentSubdir = this.getWorkingDirectory(op.path);
                 if (parentSubdir) {
-                    parentSubdir.processCreateSubDirectoryMessage(op, local, localOpMetadata);
+                    parentSubdir.processCreateSubDirectoryMessage(msg, op, local, localOpMetadata);
                 }
             },
             submit: (op, localOpMetadata) => {
@@ -475,7 +520,6 @@ export class SharedDirectory extends SharedObject {
                     parentSubdir.resubmitSubDirectoryMessage(op, localOpMetadata);
                 }
             },
-            // eslint-disable-next-line max-len
             applyStashedOp: (op) => {
                 const parentSubdir = this.getWorkingDirectory(op.path);
                 if (parentSubdir) {
@@ -484,10 +528,10 @@ export class SharedDirectory extends SharedObject {
             },
         });
         this.messageHandlers.set("deleteSubDirectory", {
-            process: (op, local, localOpMetadata) => {
+            process: (msg, op, local, localOpMetadata) => {
                 const parentSubdir = this.getWorkingDirectory(op.path);
                 if (parentSubdir) {
-                    parentSubdir.processDeleteSubDirectoryMessage(op, local, localOpMetadata);
+                    parentSubdir.processDeleteSubDirectoryMessage(msg, op, local, localOpMetadata);
                 }
             },
             submit: (op, localOpMetadata) => {
@@ -497,7 +541,6 @@ export class SharedDirectory extends SharedObject {
                     parentSubdir.resubmitSubDirectoryMessage(op, localOpMetadata);
                 }
             },
-            // eslint-disable-next-line max-len
             applyStashedOp: (op) => {
                 const parentSubdir = this.getWorkingDirectory(op.path);
                 if (parentSubdir) {
@@ -507,6 +550,7 @@ export class SharedDirectory extends SharedObject {
         });
     }
     /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObjectCore.applyStashedOp}
      * @internal
      */
     applyStashedOp(op) {
@@ -527,20 +571,20 @@ export class SharedDirectory extends SharedObject {
         while (stack.length > 0) {
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             const [currentSubDir, currentSubDirObject] = stack.pop();
+            currentSubDirObject.ci = currentSubDir.getSerializableCreateInfo();
             for (const [key, value] of currentSubDir.getSerializedStorage(serializer)) {
                 if (!currentSubDirObject.storage) {
                     currentSubDirObject.storage = {};
                 }
                 const result = {
                     type: value.type,
-                    // eslint-disable-next-line @typescript-eslint/ban-types
                     value: value.value && JSON.parse(value.value),
                 };
                 if (value.value && value.value.length >= MinValueSizeSeparateSnapshotBlob) {
                     const extraContent = {};
                     let largeContent = extraContent;
                     if (currentSubDir.absolutePath !== posix.sep) {
-                        for (const dir of currentSubDir.absolutePath.substr(1).split(posix.sep)) {
+                        for (const dir of currentSubDir.absolutePath.slice(1).split(posix.sep)) {
                             const subDataObject = {};
                             largeContent.subdirectories = { [dir]: subDataObject };
                             largeContent = subDataObject;
@@ -573,24 +617,32 @@ export class SharedDirectory extends SharedObject {
         return builder.getSummaryTree();
     }
 }
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access */
 function isKeyEditLocalOpMetadata(metadata) {
-    return metadata !== undefined && typeof metadata.pendingMessageId === "number" && metadata.type === "edit";
+    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";
+    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");
+    return (metadata !== undefined &&
+        typeof metadata.pendingMessageId === "number" &&
+        (metadata.type === "createSubDir" || metadata.type === "deleteSubDir"));
 }
 function isDirectoryLocalOpMetadata(metadata) {
-    return metadata !== undefined && typeof metadata.pendingMessageId === "number" &&
-        (metadata.type === "edit" || metadata.type === "deleteSubDir" ||
+    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"));
+            metadata.type === "createSubDir"));
 }
+/* eslint-enable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access */
 /**
  * Node of the directory tree.
  * @sealed
@@ -598,13 +650,17 @@ function isDirectoryLocalOpMetadata(metadata) {
 class SubDirectory extends TypedEventEmitter {
     /**
      * Constructor.
+     * @param sequenceNumber - Message seq number at which this was created.
+     * @param clientIds - Ids of client which created this directory.
      * @param directory - Reference back to the SharedDirectory to perform operations
      * @param runtime - The data store runtime this directory is associated with
      * @param serializer - The serializer to serialize / parse handles
      * @param absolutePath - The absolute path of this IDirectory
      */
-    constructor(directory, runtime, serializer, absolutePath) {
+    constructor(sequenceNumber, clientIds, directory, runtime, serializer, absolutePath) {
         super();
+        this.sequenceNumber = sequenceNumber;
+        this.clientIds = clientIds;
         this.directory = directory;
         this.runtime = runtime;
         this.serializer = serializer;
@@ -630,9 +686,14 @@ class SubDirectory extends TypedEventEmitter {
          */
         this.pendingKeys = new Map();
         /**
-         * Subdirectories that have been modified locally but not yet ack'd from the server.
+         * Subdirectories that have been created/deleted locally but not yet ack'd from the server.
          */
         this.pendingSubDirectories = new Map();
+        /**
+         * Subdirectories that have been deleted locally but not yet ack'd from the server. This maintains the count
+         * of delete op that are pending or yet to be acked from server.
+         */
+        this.pendingDeleteSubDirectoriesCount = new Map();
         /**
          * This is used to assign a unique id to every outgoing operation and helps in tracking unack'd ops.
          */
@@ -647,10 +708,11 @@ class SubDirectory extends TypedEventEmitter {
         this.emit("disposed", this);
     }
     /**
-     * Unmark the deleted property when rolling back delete.
+     * Unmark the deleted property only when rolling back delete.
      */
     undispose() {
         this._deleted = false;
+        this.emit("undisposed", this);
     }
     get disposed() {
         return this._deleted;
@@ -714,6 +776,7 @@ class SubDirectory extends TypedEventEmitter {
      * {@inheritDoc IDirectory.createSubDirectory}
      */
     createSubDirectory(subdirName) {
+        var _c;
         this.throwIfDisposed();
         // Undefined/null subdirectory names can't be serialized to JSON in the manner we currently snapshot.
         if (subdirName === undefined || subdirName === null) {
@@ -723,19 +786,22 @@ class SubDirectory extends TypedEventEmitter {
             throw new Error(`SubDirectory name may not contain ${posix.sep}`);
         }
         // Create the sub directory locally first.
-        const isNew = this.createSubDirectoryCore(subdirName, true);
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const isNew = this.createSubDirectoryCore(subdirName, true, -1, (_c = this.runtime.clientId) !== null && _c !== void 0 ? _c : "detached");
         const subDir = this._subdirectories.get(subdirName);
+        assert(subDir !== undefined, 0x5aa /* subdirectory should exist after creation */);
         // If we are not attached, don't submit the op.
         if (!this.directory.isAttached()) {
             return subDir;
         }
-        const op = {
-            path: this.absolutePath,
-            subdirName,
-            type: "createSubDirectory",
-        };
-        this.submitCreateSubDirectoryMessage(op, !isNew);
+        // Only submit the op, if it is newly created.
+        if (isNew) {
+            const op = {
+                path: this.absolutePath,
+                subdirName,
+                type: "createSubDirectory",
+            };
+            this.submitCreateSubDirectoryMessage(op);
+        }
         return subDir;
     }
     /**
@@ -763,12 +829,15 @@ class SubDirectory extends TypedEventEmitter {
         if (!this.directory.isAttached()) {
             return subDir !== undefined;
         }
-        const op = {
-            path: this.absolutePath,
-            subdirName,
-            type: "deleteSubDirectory",
-        };
-        this.submitDeleteSubDirectoryMessage(op, subDir);
+        // Only submit the op, if the directory existed and we deleted it.
+        if (subDir !== undefined) {
+            const op = {
+                path: this.absolutePath,
+                subdirName,
+                type: "deleteSubDirectory",
+            };
+            this.submitDeleteSubDirectoryMessage(op, subDir);
+        }
         return subDir !== undefined;
     }
     /**
@@ -785,6 +854,18 @@ class SubDirectory extends TypedEventEmitter {
         this.throwIfDisposed();
         return this.directory.getWorkingDirectory(this.makeAbsolute(relativePath));
     }
+    /**
+     * This checks if there is pending delete op for local delete for a given child subdirectory.
+     * @param subDirName - directory name.
+     * @returns - true if there is pending delete.
+     */
+    isSubDirectoryDeletePending(subDirName) {
+        const pendingDeleteSubDirectory = this.pendingDeleteSubDirectoriesCount.get(subDirName);
+        if (pendingDeleteSubDirectory !== undefined && pendingDeleteSubDirectory > 0) {
+            return true;
+        }
+        return false;
+    }
     /**
      * Deletes the given key from within this IDirectory.
      * @param key - The key to delete
@@ -830,6 +911,7 @@ class SubDirectory extends TypedEventEmitter {
      */
     forEach(callback) {
         this.throwIfDisposed();
+        // eslint-disable-next-line unicorn/no-array-for-each
         this._storage.forEach((localValue, key, map) => {
             callback(localValue.value, key, map);
         });
@@ -899,14 +981,18 @@ class SubDirectory extends TypedEventEmitter {
     }
     /**
      * Process a clear operation.
+     * @param msg - The message from the server to apply.
      * @param op - The op to process
      * @param local - Whether the message originated from 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.
      * @internal
      */
-    processClearMessage(op, local, localOpMetadata) {
+    processClearMessage(msg, op, local, localOpMetadata) {
         this.throwIfDisposed();
+        if (!this.isMessageForCurrentInstanceOfSubDirectory(msg)) {
+            return;
+        }
         if (local) {
             assert(isClearLocalOpMetadata(localOpMetadata), 0x00f /* pendingMessageId is missing from the local client's operation */);
             const pendingClearMessageId = this.pendingClearMessageIds.shift();
@@ -935,15 +1021,17 @@ class SubDirectory extends TypedEventEmitter {
     }
     /**
      * Process a delete operation.
+     * @param msg - The message from the server to apply.
      * @param op - The op to process
      * @param local - Whether the message originated from 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.
      * @internal
      */
-    processDeleteMessage(op, local, localOpMetadata) {
+    processDeleteMessage(msg, op, local, localOpMetadata) {
         this.throwIfDisposed();
-        if (!this.needProcessStorageOperation(op, local, localOpMetadata)) {
+        if (!(this.isMessageForCurrentInstanceOfSubDirectory(msg) &&
+            this.needProcessStorageOperation(op, local, localOpMetadata))) {
             return;
         }
         this.deleteCore(op.key, local);
@@ -957,20 +1045,26 @@ class SubDirectory extends TypedEventEmitter {
         this.throwIfDisposed();
         const previousValue = this.deleteCore(op.key, true);
         const pendingMessageId = this.getKeyMessageId(op);
-        const localMetadata = { type: "edit", pendingMessageId, previousValue };
+        const localMetadata = {
+            type: "edit",
+            pendingMessageId,
+            previousValue,
+        };
         return localMetadata;
     }
     /**
      * Process a set operation.
+     * @param msg - The message from the server to apply.
      * @param op - The op to process
      * @param local - Whether the message originated from 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.
      * @internal
      */
-    processSetMessage(op, context, local, localOpMetadata) {
+    processSetMessage(msg, op, context, local, localOpMetadata) {
         this.throwIfDisposed();
-        if (!this.needProcessStorageOperation(op, local, localOpMetadata)) {
+        if (!(this.isMessageForCurrentInstanceOfSubDirectory(msg) &&
+            this.needProcessStorageOperation(op, local, localOpMetadata))) {
             return;
         }
         // needProcessStorageOperation should have returned false if local is true
@@ -989,23 +1083,28 @@ class SubDirectory extends TypedEventEmitter {
         const previousValue = this.setCore(op.key, context, true);
         // Create metadata
         const pendingMessageId = this.getKeyMessageId(op);
-        const localMetadata = { type: "edit", pendingMessageId, previousValue };
+        const localMetadata = {
+            type: "edit",
+            pendingMessageId,
+            previousValue,
+        };
         return localMetadata;
     }
     /**
      * Process a create subdirectory operation.
+     * @param msg - The message from the server to apply.
      * @param op - The op to process
      * @param local - Whether the message originated from 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.
      * @internal
      */
-    processCreateSubDirectoryMessage(op, local, localOpMetadata) {
+    processCreateSubDirectoryMessage(msg, op, local, localOpMetadata) {
         this.throwIfDisposed();
-        if (!this.needProcessSubDirectoryOperation(op, local, localOpMetadata)) {
+        if (!this.needProcessSubDirectoryOperation(msg, op, local, localOpMetadata)) {
             return;
         }
-        this.createSubDirectoryCore(op.subdirName, local);
+        this.createSubDirectoryCore(op.subdirName, local, msg.sequenceNumber, msg.clientId);
     }
     /**
      * Apply createSubDirectory operation locally and generate metadata
@@ -1013,28 +1112,30 @@ class SubDirectory extends TypedEventEmitter {
      * @returns metadata generated for stahed op
      */
     applyStashedCreateSubDirMessage(op) {
+        var _c;
         this.throwIfDisposed();
         // Create the sub directory locally first.
-        const isNew = this.createSubDirectoryCore(op.subdirName, true);
+        this.createSubDirectoryCore(op.subdirName, true, -1, (_c = this.runtime.clientId) !== null && _c !== void 0 ? _c : "detached");
         const newMessageId = this.getSubDirMessageId(op);
         const localOpMetadata = {
             type: "createSubDir",
             pendingMessageId: newMessageId,
-            previouslyExisted: !isNew,
         };
         return localOpMetadata;
     }
     /**
      * Process a delete subdirectory operation.
+     * @param msg - The message from the server to apply.
      * @param op - The op to process
      * @param local - Whether the message originated from 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.
      * @internal
      */
-    processDeleteSubDirectoryMessage(op, local, localOpMetadata) {
+    processDeleteSubDirectoryMessage(msg, op, local, localOpMetadata) {
         this.throwIfDisposed();
-        if (!this.needProcessSubDirectoryOperation(op, local, localOpMetadata)) {
+        if (!(this.isMessageForCurrentInstanceOfSubDirectory(msg) &&
+            this.needProcessSubDirectoryOperation(msg, op, local, localOpMetadata))) {
             return;
         }
         this.deleteSubDirectoryCore(op.subdirName, local);
@@ -1118,7 +1219,8 @@ class SubDirectory extends TypedEventEmitter {
         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 */);
+        assert(pendingMessageIds !== undefined &&
+            pendingMessageIds[0] === localOpMetadata.pendingMessageId, 0x32e /* Unexpected pending message received */);
         pendingMessageIds.shift();
         if (pendingMessageIds.length === 0) {
             this.pendingKeys.delete(op.key);
@@ -1129,6 +1231,7 @@ class SubDirectory extends TypedEventEmitter {
      * Get a new pending message id for the op and cache it to track the pending op
      */
     getSubDirMessageId(op) {
+        var _c;
         // 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);
@@ -1138,20 +1241,22 @@ class SubDirectory extends TypedEventEmitter {
         else {
             this.pendingSubDirectories.set(op.subdirName, [newMessageId]);
         }
+        if (op.type === "deleteSubDirectory") {
+            const count = (_c = this.pendingDeleteSubDirectoriesCount.get(op.subdirName)) !== null && _c !== void 0 ? _c : 0;
+            this.pendingDeleteSubDirectoriesCount.set(op.subdirName, count + 1);
+        }
         return newMessageId;
     }
     /**
      * Submit a create subdirectory operation.
      * @param op - The operation
-     * @param prevExisted - Whether the subdirectory existed before the op
      */
-    submitCreateSubDirectoryMessage(op, prevExisted) {
+    submitCreateSubDirectoryMessage(op) {
         this.throwIfDisposed();
         const newMessageId = this.getSubDirMessageId(op);
         const localOpMetadata = {
             type: "createSubDir",
             pendingMessageId: newMessageId,
-            previouslyExisted: prevExisted,
         };
         this.directory.submitDirectoryMessage(op, localOpMetadata);
     }
@@ -1180,13 +1285,14 @@ class SubDirectory extends TypedEventEmitter {
         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 */);
+        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);
+            this.submitCreateSubDirectoryMessage(op);
         }
         else {
             this.submitDeleteSubDirectoryMessage(op, localOpMetadata.subDirectory);
@@ -1206,6 +1312,14 @@ class SubDirectory extends TypedEventEmitter {
             yield res;
         }
     }
+    getSerializableCreateInfo() {
+        this.throwIfDisposed();
+        const createInfo = {
+            csn: this.sequenceNumber,
+            ccIds: Array.from(this.clientIds),
+        };
+        return createInfo;
+    }
     /**
      * Populate a key value in this subdirectory's storage, to be used when loading from snapshot.
      * @param key - The key to populate
@@ -1252,21 +1366,24 @@ class SubDirectory extends TypedEventEmitter {
             map.delete(key);
         }
     }
+    /* eslint-disable @typescript-eslint/no-unsafe-member-access */
     /**
      * Rollback a local op
      * @param op - The operation to rollback
      * @param localOpMetadata - The local metadata associated with the op.
      */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     rollback(op, localOpMetadata) {
         if (!isDirectoryLocalOpMetadata(localOpMetadata)) {
             throw new Error("Invalid localOpMetadata");
         }
         if (op.type === "clear" && localOpMetadata.type === "clear") {
-            localOpMetadata.previousStorage.forEach((localValue, key) => {
+            for (const [key, localValue] of localOpMetadata.previousStorage.entries()) {
                 this.setCore(key, localValue, true);
-            });
+            }
             const lastPendingClearId = this.pendingClearMessageIds.pop();
-            if (lastPendingClearId === undefined || lastPendingClearId !== localOpMetadata.pendingMessageId) {
+            if (lastPendingClearId === undefined ||
+                lastPendingClearId !== localOpMetadata.pendingMessageId) {
                 throw new Error("Rollback op does match last clear");
             }
         }
@@ -1280,9 +1397,7 @@ class SubDirectory extends TypedEventEmitter {
             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.deleteSubDirectoryCore(op.subdirName, true);
             this.rollbackPendingMessageId(this.pendingSubDirectories, op.subdirName, localOpMetadata.pendingMessageId);
         }
         else if (op.type === "deleteSubDirectory" && localOpMetadata.type === "deleteSubDir") {
@@ -1293,11 +1408,18 @@ class SubDirectory extends TypedEventEmitter {
                 this.emit("subDirectoryCreated", op.subdirName, true, this);
             }
             this.rollbackPendingMessageId(this.pendingSubDirectories, op.subdirName, localOpMetadata.pendingMessageId);
+            const count = this.pendingDeleteSubDirectoriesCount.get(op.subdirName);
+            assert(count !== undefined && count > 0, 0x5ab /* should have record for delete op */);
+            this.pendingDeleteSubDirectoriesCount.set(op.subdirName, count - 1);
+            if (count === 1) {
+                this.pendingDeleteSubDirectoriesCount.delete(op.subdirName);
+            }
         }
         else {
             throw new Error("Unsupported op for rollback");
         }
     }
+    /* eslint-enable @typescript-eslint/no-unsafe-member-access */
     /**
      * Converts the given relative path into an absolute path.
      * @param path - Relative path to convert
@@ -1318,8 +1440,25 @@ class SubDirectory extends TypedEventEmitter {
     needProcessStorageOperation(op, local, localOpMetadata) {
         if (this.pendingClearMessageIds.length > 0) {
             if (local) {
-                assert(localOpMetadata !== undefined && isKeyEditLocalOpMetadata(localOpMetadata) &&
+                assert(localOpMetadata !== undefined &&
+                    isKeyEditLocalOpMetadata(localOpMetadata) &&
                     localOpMetadata.pendingMessageId < this.pendingClearMessageIds[0], 0x010 /* "Received out of order storage op when there is an unackd clear message" */);
+                // Remove all pendingMessageIds lower than first pendingClearMessageId.
+                const lowestPendingClearMessageId = this.pendingClearMessageIds[0];
+                const pendingKeyMessageIdArray = this.pendingKeys.get(op.key);
+                if (pendingKeyMessageIdArray !== undefined) {
+                    let index = 0;
+                    while (pendingKeyMessageIdArray[index] < lowestPendingClearMessageId) {
+                        index += 1;
+                    }
+                    const newPendingKeyMessageId = pendingKeyMessageIdArray.splice(index);
+                    if (newPendingKeyMessageId.length === 0) {
+                        this.pendingKeys.delete(op.key);
+                    }
+                    else {
+                        this.pendingKeys.set(op.key, newPendingKeyMessageId);
+                    }
+                }
             }
             // If I have a NACK clear, we can ignore all ops.
             return false;
@@ -1331,7 +1470,8 @@ class SubDirectory extends TypedEventEmitter {
             if (local) {
                 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 */);
+                assert(pendingMessageIds !== undefined &&
+                    pendingMessageIds[0] === localOpMetadata.pendingMessageId, 0x331 /* Unexpected pending message received */);
                 pendingMessageIds.shift();
                 if (pendingMessageIds.length === 0) {
                     this.pendingKeys.delete(op.key);
@@ -1342,6 +1482,19 @@ class SubDirectory extends TypedEventEmitter {
         // If we don't have a NACK op on the key, we need to process the remote ops.
         return !local;
     }
+    /**
+     * This return true if the message is for the current instance of this sub directory. As the sub directory
+     * can be deleted and created again, then this finds if the message is for current instance of directory or not.
+     * @param msg - message for the directory
+     */
+    isMessageForCurrentInstanceOfSubDirectory(msg) {
+        // If the message is either from the creator of directory or this directory was created when
+        // container was detached or in case this directory is already live(known to other clients)
+        // and the op was created after the directory was created then apply this op.
+        return (this.clientIds.has(msg.clientId) ||
+            this.clientIds.has("detached") ||
+            (this.sequenceNumber !== -1 && this.sequenceNumber <= msg.referenceSequenceNumber));
+    }
     /**
      * If our local operations that have not yet been ack'd will eventually overwrite an incoming operation, we should
      * not process the incoming operation.
@@ -1352,17 +1505,52 @@ class SubDirectory extends TypedEventEmitter {
      * For messages from a remote client, this will be undefined.
      * @returns True if the operation should be processed, false otherwise
      */
-    needProcessSubDirectoryOperation(op, local, localOpMetadata) {
+    needProcessSubDirectoryOperation(msg, op, local, localOpMetadata) {
         const pendingSubDirectoryMessageId = this.pendingSubDirectories.get(op.subdirName);
         if (pendingSubDirectoryMessageId !== undefined) {
             if (local) {
                 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 */);
+                assert(pendingMessageIds !== undefined &&
+                    pendingMessageIds[0] === localOpMetadata.pendingMessageId, 0x332 /* Unexpected pending message received */);
                 pendingMessageIds.shift();
                 if (pendingMessageIds.length === 0) {
                     this.pendingSubDirectories.delete(op.subdirName);
                 }
+                if (op.type === "deleteSubDirectory") {
+                    const count = this.pendingDeleteSubDirectoriesCount.get(op.subdirName);
+                    assert(count !== undefined && count > 0, 0x5ac /* should have record for delete op */);
+                    this.pendingDeleteSubDirectoriesCount.set(op.subdirName, count - 1);
+                    if (count === 1) {
+                        this.pendingDeleteSubDirectoriesCount.delete(op.subdirName);
+                    }
+                }
+            }
+            else if (op.type === "deleteSubDirectory") {
+                // If this is remote delete op and we have keys in this subDirectory, then we need to delete these
+                // keys except the pending ones as they will be sequenced after this delete.
+                const subDirectory = this._subdirectories.get(op.subdirName);
+                if (subDirectory) {
+                    subDirectory.clearExceptPendingKeys(local);
+                    // In case of remote delete op, we need to reset the creation seq number and client ids of
+                    // creators as the previous directory is getting deleted and we will initialize again when
+                    // we will receive op for the create again.
+                    subDirectory.sequenceNumber = -1;
+                    subDirectory.clientIds.clear();
+                }
+            }
+            if (op.type === "createSubDirectory") {
+                const dir = this._subdirectories.get(op.subdirName);
+                if ((dir === null || dir === void 0 ? void 0 : dir.sequenceNumber) === -1) {
+                    // Only set the seq on the first message, could be more
+                    dir.sequenceNumber = msg.sequenceNumber;
+                }
+                // The client created the dir at or after the dirs seq, so list its client id as a creator.
+                if (dir !== undefined &&
+                    !dir.clientIds.has(msg.clientId) &&
+                    dir.sequenceNumber <= msg.sequenceNumber) {
+                    dir.clientIds.add(msg.clientId);
+                }
             }
             return false;
         }
@@ -1375,14 +1563,17 @@ class SubDirectory extends TypedEventEmitter {
         // Assuming the pendingKeys is small and the map is large
         // we will get the value for the pendingKeys and clear the map
         const temp = new Map();
-        this.pendingKeys.forEach((value, key, map) => {
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            temp.set(key, this._storage.get(key));
-        });
+        for (const [key] of this.pendingKeys) {
+            const value = this._storage.get(key);
+            // If this key is already deleted, then we don't need to add it again.
+            if (value !== undefined) {
+                temp.set(key, value);
+            }
+        }
         this.clearCore(local);
-        temp.forEach((value, key, map) => {
+        for (const [key, value] of temp.entries()) {
             this.setCore(key, value, true);
-        });
+        }
     }
     /**
      * Clear implementation used for both locally sourced clears as well as incoming remote clears.
@@ -1431,17 +1622,23 @@ class SubDirectory extends TypedEventEmitter {
      * 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
+     * @param seq - Sequence number at which this directory is created
+     * @param clientId - Id of client which created this directory.
      * @returns - True if is newly created, false if it already existed.
      */
-    createSubDirectoryCore(subdirName, local) {
-        if (!this._subdirectories.has(subdirName)) {
+    createSubDirectoryCore(subdirName, local, seq, clientId) {
+        const subdir = this._subdirectories.get(subdirName);
+        if (subdir === undefined) {
             const absolutePath = posix.join(this.absolutePath, subdirName);
-            const subDir = new SubDirectory(this.directory, this.runtime, this.serializer, absolutePath);
+            const subDir = new SubDirectory(seq, new Set([clientId]), this.directory, this.runtime, this.serializer, absolutePath);
             this.registerEventsOnSubDirectory(subDir, subdirName);
             this._subdirectories.set(subdirName, subDir);
             this.emit("subDirectoryCreated", subdirName, local, this);
             return true;
         }
+        else {
+            subdir.clientIds.add(clientId);
+        }
         return false;
     }
     registerEventsOnSubDirectory(subDirectory, subDirName) {