@fluidframework/map 2.118.0 → 3.0.0

package/lib/directory.js

@@ -2,7 +2,6 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-var _a, _b;
 // TODO: Fix prefer-nullish-coalescing and prefer-optional-chain lint violations
 /* eslint-disable @typescript-eslint/prefer-nullish-coalescing, @typescript-eslint/prefer-optional-chain */
 import { TypedEventEmitter } from "@fluid-internal/client-utils";
@@ -76,12 +75,24 @@ function isAcknowledgedOrDetached(seqData) {
  * @sealed
  */
 export class SharedDirectory extends SharedObject {
+    /**
+     * String representation for the class.
+     */
+    [Symbol.toStringTag] = "SharedDirectory";
     /**
      * {@inheritDoc IDirectory.absolutePath}
      */
     get absolutePath() {
         return this.root.absolutePath;
     }
+    /**
+     * Root of the SharedDirectory, most operations on the SharedDirectory itself act on the root.
+     */
+    root = new SubDirectory({ seq: 0, clientSeq: 0 }, new Set(), this, this.runtime, this.serializer, posix.sep, extractTelemetryLoggerExt(this.logger));
+    /**
+     * Mapping of op types to message handlers.
+     */
+    messageHandlers = new Map();
     /**
      * Constructs a new shared directory. If the object is non-local an id and service interfaces will
      * be provided.
@@ -91,18 +102,6 @@ export class SharedDirectory extends SharedObject {
      */
     constructor(id, runtime, attributes) {
         super(id, runtime, attributes, "fluid_directory_");
-        /**
-         * String representation for the class.
-         */
-        this[_a] = "SharedDirectory";
-        /**
-         * Root of the SharedDirectory, most operations on the SharedDirectory itself act on the root.
-         */
-        this.root = new SubDirectory({ seq: 0, clientSeq: 0 }, new Set(), this, this.runtime, this.serializer, posix.sep, extractTelemetryLoggerExt(this.logger));
-        /**
-         * Mapping of op types to message handlers.
-         */
-        this.messageHandlers = new Map();
         this.setMessageHandlers();
         // Mirror the containedValueChanged op on the SharedDirectory
         this.root.on("containedValueChanged", (changed, local) => {
@@ -180,7 +179,7 @@ export class SharedDirectory extends SharedObject {
      */
     // TODO: Use `unknown` instead (breaking change).
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    [(_a = Symbol.toStringTag, Symbol.iterator)]() {
+    [Symbol.iterator]() {
         return this.root[Symbol.iterator]();
     }
     /**
@@ -603,6 +602,31 @@ function assertNonNullClientId(clientId) {
  * @sealed
  */
 class SubDirectory extends TypedEventEmitter {
+    seqData;
+    clientIds;
+    directory;
+    runtime;
+    serializer;
+    absolutePath;
+    /**
+     * Tells if the sub directory is deleted or not.
+     */
+    _deleted = false;
+    /**
+     * String representation for the class.
+     */
+    [Symbol.toStringTag] = "SubDirectory";
+    /**
+     * The sequenced subdirectories the directory is holding independent of any pending
+     * create/delete subdirectory operations.
+     */
+    _sequencedSubdirectories = new Map();
+    /**
+     * Assigns a unique ID to each subdirectory created locally but pending for acknowledgement, facilitating the tracking
+     * of the creation order.
+     */
+    localCreationSeq = 0;
+    mc;
     /**
      * Constructor.
      * @param sequenceNumber - Message seq number at which this was created.
@@ -620,156 +644,6 @@ class SubDirectory extends TypedEventEmitter {
         this.runtime = runtime;
         this.serializer = serializer;
         this.absolutePath = absolutePath;
-        /**
-         * Tells if the sub directory is deleted or not.
-         */
-        this._deleted = false;
-        /**
-         * String representation for the class.
-         */
-        this[_b] = "SubDirectory";
-        /**
-         * The sequenced subdirectories the directory is holding independent of any pending
-         * create/delete subdirectory operations.
-         */
-        this._sequencedSubdirectories = new Map();
-        /**
-         * Assigns a unique ID to each subdirectory created locally but pending for acknowledgement, facilitating the tracking
-         * of the creation order.
-         */
-        this.localCreationSeq = 0;
-        /**
-         * The data this SubDirectory instance is storing, but only including sequenced values (no local pending
-         * modifications are included).
-         */
-        this.sequencedStorageData = new Map();
-        /**
-         * A data structure containing all local pending storage modifications, which is used in combination
-         * with the sequencedStorageData to compute optimistic values.
-         *
-         * Pending sets are aggregated into "lifetimes", which permit correct relative iteration order
-         * even across remote operations and rollbacks.
-         */
-        this.pendingStorageData = [];
-        /**
-         * A data structure containing all local pending subdirectory create/deletes, which is used in combination
-         * with the _sequencedSubdirectories to compute optimistic values.
-         */
-        this.pendingSubDirectoryData = [];
-        /**
-         * An internal iterator that iterates over the entries in the directory.
-         */
-        this.internalIterator = () => {
-            // We perform iteration in two steps - first by iterating over members of the sequenced storage data that are not
-            // optimistically deleted or cleared, and then over the pending data lifetimes that have not subsequently
-            // been deleted or cleared.  In total, this give an ordering of members based on when they were initially
-            // added to the sub directory (even if they were later modified), similar to the native Map.
-            const sequencedStorageDataIterator = this.sequencedStorageData.keys();
-            const pendingStorageDataIterator = this.pendingStorageData.values();
-            const next = () => {
-                let nextSequencedKey = sequencedStorageDataIterator.next();
-                while (!nextSequencedKey.done) {
-                    const key = nextSequencedKey.value;
-                    // If we have any pending deletes or clears, then we won't iterate to this key yet (if at all).
-                    // Either it is optimistically deleted and will not be part of the iteration, or it was
-                    // re-added later and we'll iterate to it when we get to the pending data.
-                    if (!this.pendingStorageData.some((entry) => entry.type === "clear" || (entry.type === "delete" && entry.key === key))) {
-                        assert(this.has(key), 0xc03 /* key should exist in sequenced or pending data */);
-                        const optimisticValue = this.getOptimisticValue(key);
-                        return { value: [key, optimisticValue], done: false };
-                    }
-                    nextSequencedKey = sequencedStorageDataIterator.next();
-                }
-                let nextPending = pendingStorageDataIterator.next();
-                while (!nextPending.done) {
-                    const nextPendingEntry = nextPending.value;
-                    // A lifetime entry may need to be iterated.
-                    if (nextPendingEntry.type === "lifetime") {
-                        const nextPendingEntryIndex = this.pendingStorageData.indexOf(nextPendingEntry);
-                        const mostRecentDeleteOrClearIndex = findLastIndex(this.pendingStorageData, (entry) => entry.type === "clear" ||
-                            (entry.type === "delete" && entry.key === nextPendingEntry.key));
-                        // Only iterate the pending entry now if it hasn't been deleted or cleared.
-                        if (nextPendingEntryIndex > mostRecentDeleteOrClearIndex) {
-                            const latestPendingValue = 
-                            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                            nextPendingEntry.keySets[nextPendingEntry.keySets.length - 1];
-                            // Skip iterating if we would have would have already iterated it as part of the sequenced data.
-                            // This is not a perfect check in the case the map has changed since the iterator was created
-                            // (e.g. if a remote client added the same key in the meantime).
-                            if (!this.sequencedStorageData.has(nextPendingEntry.key) ||
-                                mostRecentDeleteOrClearIndex !== -1) {
-                                return { value: [nextPendingEntry.key, latestPendingValue.value], done: false };
-                            }
-                        }
-                    }
-                    nextPending = pendingStorageDataIterator.next();
-                }
-                return { value: undefined, done: true };
-            };
-            const iterator = {
-                next,
-                [Symbol.iterator]() {
-                    return this;
-                },
-            };
-            return iterator;
-        };
-        /**
-         * Compute the optimistic local value for a given key. This combines the sequenced data with
-         * any pending changes that have not yet been sequenced.
-         */
-        this.getOptimisticValue = (key) => {
-            const latestPendingEntry = findLast(this.pendingStorageData, (entry) => entry.type === "clear" || entry.key === key);
-            if (latestPendingEntry === undefined) {
-                return this.sequencedStorageData.get(key);
-            }
-            else if (latestPendingEntry.type === "lifetime") {
-                const latestPendingSet = 
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                latestPendingEntry.keySets[latestPendingEntry.keySets.length - 1];
-                return latestPendingSet.value;
-            }
-            else {
-                // Delete or clear
-                return undefined;
-            }
-        };
-        /**
-         * Determine if the directory optimistically has the key.
-         * This will return true even if the value is undefined.
-         */
-        this.optimisticallyHas = (key) => {
-            const latestPendingEntry = findLast(this.pendingStorageData, (entry) => entry.type === "clear" || entry.key === key);
-            return latestPendingEntry === undefined
-                ? this.sequencedStorageData.has(key)
-                : latestPendingEntry.type === "lifetime";
-        };
-        /**
-         * Get the optimistic local subdirectory. This combines the sequenced data with
-         * any pending changes that have not yet been sequenced. By default, we do not
-         * consider disposed directories as optimistically existing, but if `getIfDisposed`
-         * is true, we will include them since some scenarios require this.
-         */
-        this.getOptimisticSubDirectory = (subdirName, getIfDisposed = false) => {
-            const latestPendingEntry = findLast(this.pendingSubDirectoryData, (entry) => entry.subdirName === subdirName);
-            let subdir;
-            if (latestPendingEntry === undefined) {
-                subdir = this._sequencedSubdirectories.get(subdirName);
-            }
-            else if (latestPendingEntry.type === "createSubDirectory") {
-                subdir = latestPendingEntry.subdir;
-                assert(subdir !== undefined, 0xc2f /* Subdirectory should exist in pending data */);
-            }
-            else {
-                // Pending delete
-                return undefined;
-            }
-            // If the subdirectory is disposed, treat it as non-existent for optimistic reads (unless specified otherwise)
-            if (subdir?.disposed && !getIfDisposed) {
-                return undefined;
-            }
-            return subdir;
-        };
         this.mc = createChildMonitoringContext({ logger, namespace: "Directory" });
     }
     dispose(error) {
@@ -1235,10 +1109,142 @@ class SubDirectory extends TypedEventEmitter {
      * Get an iterator over the entries under this IDirectory.
      * @returns The iterator
      */
-    [(_b = Symbol.toStringTag, Symbol.iterator)]() {
+    [Symbol.iterator]() {
         this.throwIfDisposed();
         return this.internalIterator();
     }
+    /**
+     * The data this SubDirectory instance is storing, but only including sequenced values (no local pending
+     * modifications are included).
+     */
+    sequencedStorageData = new Map();
+    /**
+     * A data structure containing all local pending storage modifications, which is used in combination
+     * with the sequencedStorageData to compute optimistic values.
+     *
+     * Pending sets are aggregated into "lifetimes", which permit correct relative iteration order
+     * even across remote operations and rollbacks.
+     */
+    pendingStorageData = [];
+    /**
+     * A data structure containing all local pending subdirectory create/deletes, which is used in combination
+     * with the _sequencedSubdirectories to compute optimistic values.
+     */
+    pendingSubDirectoryData = [];
+    /**
+     * An internal iterator that iterates over the entries in the directory.
+     */
+    internalIterator = () => {
+        // We perform iteration in two steps - first by iterating over members of the sequenced storage data that are not
+        // optimistically deleted or cleared, and then over the pending data lifetimes that have not subsequently
+        // been deleted or cleared.  In total, this give an ordering of members based on when they were initially
+        // added to the sub directory (even if they were later modified), similar to the native Map.
+        const sequencedStorageDataIterator = this.sequencedStorageData.keys();
+        const pendingStorageDataIterator = this.pendingStorageData.values();
+        const next = () => {
+            let nextSequencedKey = sequencedStorageDataIterator.next();
+            while (!nextSequencedKey.done) {
+                const key = nextSequencedKey.value;
+                // If we have any pending deletes or clears, then we won't iterate to this key yet (if at all).
+                // Either it is optimistically deleted and will not be part of the iteration, or it was
+                // re-added later and we'll iterate to it when we get to the pending data.
+                if (!this.pendingStorageData.some((entry) => entry.type === "clear" || (entry.type === "delete" && entry.key === key))) {
+                    assert(this.has(key), 0xc03 /* key should exist in sequenced or pending data */);
+                    const optimisticValue = this.getOptimisticValue(key);
+                    return { value: [key, optimisticValue], done: false };
+                }
+                nextSequencedKey = sequencedStorageDataIterator.next();
+            }
+            let nextPending = pendingStorageDataIterator.next();
+            while (!nextPending.done) {
+                const nextPendingEntry = nextPending.value;
+                // A lifetime entry may need to be iterated.
+                if (nextPendingEntry.type === "lifetime") {
+                    const nextPendingEntryIndex = this.pendingStorageData.indexOf(nextPendingEntry);
+                    const mostRecentDeleteOrClearIndex = findLastIndex(this.pendingStorageData, (entry) => entry.type === "clear" ||
+                        (entry.type === "delete" && entry.key === nextPendingEntry.key));
+                    // Only iterate the pending entry now if it hasn't been deleted or cleared.
+                    if (nextPendingEntryIndex > mostRecentDeleteOrClearIndex) {
+                        const latestPendingValue = 
+                        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                        nextPendingEntry.keySets[nextPendingEntry.keySets.length - 1];
+                        // Skip iterating if we would have would have already iterated it as part of the sequenced data.
+                        // This is not a perfect check in the case the map has changed since the iterator was created
+                        // (e.g. if a remote client added the same key in the meantime).
+                        if (!this.sequencedStorageData.has(nextPendingEntry.key) ||
+                            mostRecentDeleteOrClearIndex !== -1) {
+                            return { value: [nextPendingEntry.key, latestPendingValue.value], done: false };
+                        }
+                    }
+                }
+                nextPending = pendingStorageDataIterator.next();
+            }
+            return { value: undefined, done: true };
+        };
+        const iterator = {
+            next,
+            [Symbol.iterator]() {
+                return this;
+            },
+        };
+        return iterator;
+    };
+    /**
+     * Compute the optimistic local value for a given key. This combines the sequenced data with
+     * any pending changes that have not yet been sequenced.
+     */
+    getOptimisticValue = (key) => {
+        const latestPendingEntry = findLast(this.pendingStorageData, (entry) => entry.type === "clear" || entry.key === key);
+        if (latestPendingEntry === undefined) {
+            return this.sequencedStorageData.get(key);
+        }
+        else if (latestPendingEntry.type === "lifetime") {
+            const latestPendingSet = 
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            latestPendingEntry.keySets[latestPendingEntry.keySets.length - 1];
+            return latestPendingSet.value;
+        }
+        else {
+            // Delete or clear
+            return undefined;
+        }
+    };
+    /**
+     * Determine if the directory optimistically has the key.
+     * This will return true even if the value is undefined.
+     */
+    optimisticallyHas = (key) => {
+        const latestPendingEntry = findLast(this.pendingStorageData, (entry) => entry.type === "clear" || entry.key === key);
+        return latestPendingEntry === undefined
+            ? this.sequencedStorageData.has(key)
+            : latestPendingEntry.type === "lifetime";
+    };
+    /**
+     * Get the optimistic local subdirectory. This combines the sequenced data with
+     * any pending changes that have not yet been sequenced. By default, we do not
+     * consider disposed directories as optimistically existing, but if `getIfDisposed`
+     * is true, we will include them since some scenarios require this.
+     */
+    getOptimisticSubDirectory = (subdirName, getIfDisposed = false) => {
+        const latestPendingEntry = findLast(this.pendingSubDirectoryData, (entry) => entry.subdirName === subdirName);
+        let subdir;
+        if (latestPendingEntry === undefined) {
+            subdir = this._sequencedSubdirectories.get(subdirName);
+        }
+        else if (latestPendingEntry.type === "createSubDirectory") {
+            subdir = latestPendingEntry.subdir;
+            assert(subdir !== undefined, 0xc2f /* Subdirectory should exist in pending data */);
+        }
+        else {
+            // Pending delete
+            return undefined;
+        }
+        // If the subdirectory is disposed, treat it as non-existent for optimistic reads (unless specified otherwise)
+        if (subdir?.disposed && !getIfDisposed) {
+            return undefined;
+        }
+        return subdir;
+    };
     /**
      * Checks if this directory should be considered visible in the optimistic view.
      * This requires both: