@fluidframework/sequence 0.59.3003 → 0.59.4000

package/dist/{mapKernel.d.ts → defaultMap.d.ts}

@@ -6,10 +6,8 @@ import { IFluidHandle } from "@fluidframework/core-interfaces";
 import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
 import { IFluidSerializer } from "@fluidframework/shared-object-base";
 import { TypedEventEmitter } from "@fluidframework/common-utils";
-import { ISerializableValue, ISerializedValue, IValueType, IValueTypeCreator, IValueTypeOperationValue, ISharedMapEvents } from "./mapKernelInterfaces";
-interface IMapMessageLocalMetadata {
-    pendingClearMessageId?: number;
-    pendingMessageId?: number;
+import { ISerializableValue, ISerializedValue, IValueType, IValueTypeOperationValue, ISharedDefaultMapEvents } from "./defaultMapInterfaces";
+export interface IMapMessageLocalMetadata {
     lastProcessedSeq: number;
 }
 /**
@@ -30,53 +28,10 @@ export interface IMapValueTypeOperation {
      */
     value: IValueTypeOperationValue;
 }
-/**
- * Operation indicating a value should be set for a key.
- */
-export interface IMapSetOperation {
-    /**
-     * String identifier of the operation type.
-     */
-    type: "set";
-    /**
-     * Map key being modified.
-     */
-    key: string;
-    /**
-     * Value to be set on the key.
-     */
-    value: ISerializableValue;
-}
-/**
- * Operation indicating a key should be deleted from the map.
- */
-export interface IMapDeleteOperation {
-    /**
-     * String identifier of the operation type.
-     */
-    type: "delete";
-    /**
-     * Map key being modified.
-     */
-    key: string;
-}
-/**
- * Map key operations are one of several types.
- */
-export declare type IMapKeyOperation = IMapValueTypeOperation | IMapSetOperation | IMapDeleteOperation;
-/**
- * Operation indicating the map should be cleared.
- */
-export interface IMapClearOperation {
-    /**
-     * String identifier of the operation type.
-     */
-    type: "clear";
-}
 /**
  * Description of a map delta operation
  */
-export declare type IMapOperation = IMapKeyOperation | IMapClearOperation;
+export declare type IMapOperation = IMapValueTypeOperation;
 /**
  * Defines the in-memory object structure to be used for the conversion to/from serialized.
  * Directly used in JSON.stringify, direct result from JSON.parse
@@ -88,14 +43,18 @@ export interface IMapDataObjectSerialized {
     [key: string]: ISerializedValue;
 }
 /**
- * A SharedMap is a map-like distributed data structure.
+ * A DefaultMap is a map-like distributed data structure, supporting operations on values stored by
+ * string key locations.
+ *
+ * Creation of values is implicit on access (either via `get` or a remote op application referring to
+ * a collection that wasn't previously known)
  */
-export declare class MapKernel implements IValueTypeCreator {
+export declare class DefaultMap<T> {
     private readonly serializer;
     private readonly handle;
     private readonly submitMessage;
-    private readonly isAttached;
-    readonly eventEmitter: TypedEventEmitter<ISharedMapEvents>;
+    private readonly type;
+    readonly eventEmitter: TypedEventEmitter<ISharedDefaultMapEvents>;
     /**
      * The number of key/value pairs stored in the map.
      */
@@ -108,34 +67,16 @@ export declare class MapKernel implements IValueTypeCreator {
      * The in-memory data the map is storing.
      */
     private readonly data;
-    /**
-     * Keys that have been modified locally but not yet ack'd from the server.
-     */
-    private readonly pendingKeys;
-    /**
-     * This is used to assign a unique id to every outgoing operation and helps in tracking unacked ops.
-     */
-    private pendingMessageId;
-    /**
-     * 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.
-     */
-    private pendingClearMessageId;
-    /**
-     * Object to create encapsulations of the values stored in the map.
-     */
-    private readonly localValueMaker;
     private lastProcessedSeq;
     /**
-     * Create a new shared map kernel.
+     * Create a new default map.
      * @param serializer - The serializer to serialize / parse handles
      * @param handle - The handle of the shared object using the kernel
      * @param submitMessage - A callback to submit a message through the shared object
-     * @param isAttached - To query whether the shared object should generate ops
-     * @param valueTypes - The value types to register
+     * @param type - The value type to create at values of this map
      * @param eventEmitter - The object that will emit map events
      */
-    constructor(serializer: IFluidSerializer, handle: IFluidHandle, submitMessage: (op: any, localOpMetadata: IMapMessageLocalMetadata) => void, isAttached: () => boolean, valueTypes: Readonly<IValueType<any>[]>, eventEmitter?: TypedEventEmitter<ISharedMapEvents>);
+    constructor(serializer: IFluidSerializer, handle: IFluidHandle, submitMessage: (op: any, localOpMetadata: IMapMessageLocalMetadata) => void, type: IValueType<T>, eventEmitter?: TypedEventEmitter<ISharedDefaultMapEvents>);
     /**
      * Get an iterator over the keys in this map.
      * @returns The iterator
@@ -164,35 +105,13 @@ export declare class MapKernel implements IValueTypeCreator {
     /**
      * {@inheritDoc ISharedMap.get}
      */
-    get<T = any>(key: string): T | undefined;
-    /**
-     * {@inheritDoc ISharedMap.wait}
-     */
-    wait<T = any>(key: string): Promise<T>;
+    get(key: string): T;
     /**
      * Check if a key exists in the map.
      * @param key - The key to check
      * @returns True if the key exists, false otherwise
      */
     has(key: string): boolean;
-    /**
-     * {@inheritDoc ISharedMap.set}
-     */
-    set(key: string, value: any): void;
-    /**
-     * {@inheritDoc IValueTypeCreator.createValueType}
-     */
-    createValueType(key: string, type: string, params: any): this;
-    /**
-     * Delete a key from the map.
-     * @param key - Key to delete
-     * @returns True if the key existed and was deleted, false if it did not exist
-     */
-    delete(key: string): boolean;
-    /**
-     * Clear all data from the map.
-     */
-    clear(): void;
     /**
      * Serializes the data stored in the shared map to a JSON string
      * @param serializer - The serializer to use to serialize handles in its values.
@@ -215,7 +134,7 @@ export declare class MapKernel implements IValueTypeCreator {
      * also sent if we are asked to resubmit the message.
      * @returns True if the operation was submitted, false otherwise.
      */
-    trySubmitMessage(op: any, localOpMetadata: unknown): boolean;
+    trySubmitMessage(op: any, localOpMetadata: IMapMessageLocalMetadata): boolean;
     tryGetStashedOpLocalMetadata(op: any): unknown;
     /**
      * Process the given op if a handler is registered.
@@ -227,31 +146,12 @@ export declare class MapKernel implements IValueTypeCreator {
      */
     tryProcessMessage(op: IMapOperation, local: boolean, message: ISequencedDocumentMessage | undefined, localOpMetadata: unknown): boolean;
     /**
-     * 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
-     */
-    private setCore;
-    /**
-     * Clear implementation used for both locally sourced clears as well as incoming remote clears.
-     * @param local - Whether the message originated from the local client
-     * @param op - The message if from a remote clear, or null if from a local clear
-     */
-    private clearCore;
-    /**
-     * Delete implementation used for both locally sourced deletes as well as incoming remote deletes.
-     * @param key - The key being deleted
+     * Initializes a default ValueType at the provided key.
+     * Should be used when a map operation incurs creation.
+     * @param key - The key being initialized
      * @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
-     */
-    private deleteCore;
-    /**
-     * Clear all keys in memory in response to a remote clear, but retain keys we have modified but not yet been ack'd.
      */
-    private clearExceptPendingKeys;
+    private createCore;
     /**
      * The remote ISerializableValue we're receiving (either as a result of a load or an incoming set op) will
      * have the information we need to create a real object, but will not be the real object yet.  For example,
@@ -263,34 +163,11 @@ export declare class MapKernel implements IValueTypeCreator {
      * @returns The local value that was produced
      */
     private makeLocal;
-    /**
-     * 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.
-     * @returns True if the operation should be processed, false otherwise
-     */
-    private needProcessKeyOperation;
     /**
      * Get the message handlers for the map.
      * @returns A map of string op names to IMapMessageHandlers for those ops
      */
     private getMessageHandlers;
-    private getMapClearMessageLocalMetadata;
-    /**
-     * Submit a clear message to remote clients.
-     * @param op - The clear message
-     */
-    private submitMapClearMessage;
-    private getMapKeyMessageLocalMetadata;
-    /**
-     * Submit a map key message to remote clients.
-     * @param op - The map key message
-     */
-    private submitMapKeyMessage;
     /**
      * Create an emitter for a value type to emit ops from the given key.
      * @alpha
@@ -299,5 +176,4 @@ export declare class MapKernel implements IValueTypeCreator {
      */
     private makeMapValueOpEmitter;
 }
-export {};
-//# sourceMappingURL=mapKernel.d.ts.map
+//# sourceMappingURL=defaultMap.d.ts.map

package/dist/defaultMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultMap.d.ts","sourceRoot":"","sources":["../src/defaultMap.ts"],"names":[],"mappings":"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"}

package/dist/defaultMap.js

@@ -0,0 +1,317 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultMap = void 0;
+const shared_object_base_1 = require("@fluidframework/shared-object-base");
+const common_utils_1 = require("@fluidframework/common-utils");
+const localValues_1 = require("./localValues");
+/**
+ * A DefaultMap is a map-like distributed data structure, supporting operations on values stored by
+ * string key locations.
+ *
+ * Creation of values is implicit on access (either via `get` or a remote op application referring to
+ * a collection that wasn't previously known)
+ */
+class DefaultMap {
+    /**
+     * Create a new default map.
+     * @param serializer - The serializer to serialize / parse handles
+     * @param handle - The handle of the shared object using the kernel
+     * @param submitMessage - A callback to submit a message through the shared object
+     * @param type - The value type to create at values of this map
+     * @param eventEmitter - The object that will emit map events
+     */
+    constructor(serializer, handle, submitMessage, type, eventEmitter = new common_utils_1.TypedEventEmitter()) {
+        this.serializer = serializer;
+        this.handle = handle;
+        this.submitMessage = submitMessage;
+        this.type = type;
+        this.eventEmitter = eventEmitter;
+        /**
+         * Mapping of op types to message handlers.
+         */
+        this.messageHandlers = new Map();
+        /**
+         * The in-memory data the map is storing.
+         */
+        this.data = new Map();
+        this.lastProcessedSeq = -1;
+        this.messageHandlers = this.getMessageHandlers();
+    }
+    /**
+     * The number of key/value pairs stored in the map.
+     */
+    get size() {
+        return this.data.size;
+    }
+    /**
+     * Get an iterator over the keys in this map.
+     * @returns The iterator
+     */
+    keys() {
+        return this.data.keys();
+    }
+    /**
+     * Get an iterator over the entries in this map.
+     * @returns The iterator
+     */
+    entries() {
+        const localEntriesIterator = this.data.entries();
+        const iterator = {
+            next() {
+                const nextVal = localEntriesIterator.next();
+                if (nextVal.done) {
+                    return { value: undefined, done: true };
+                }
+                else {
+                    // Unpack the stored value
+                    return { value: [nextVal.value[0], nextVal.value[1].value], done: false };
+                }
+            },
+            [Symbol.iterator]() {
+                return this;
+            },
+        };
+        return iterator;
+    }
+    /**
+     * Get an iterator over the values in this map.
+     * @returns The iterator
+     */
+    values() {
+        const localValuesIterator = this.data.values();
+        const iterator = {
+            next() {
+                const nextVal = localValuesIterator.next();
+                if (nextVal.done) {
+                    return { value: undefined, done: true };
+                }
+                else {
+                    // Unpack the stored value
+                    return { value: nextVal.value.value, done: false };
+                }
+            },
+            [Symbol.iterator]() {
+                return this;
+            },
+        };
+        return iterator;
+    }
+    /**
+     * Get an iterator over the entries in this map.
+     * @returns The iterator
+     */
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    /**
+     * Executes the given callback on each entry in the map.
+     * @param callbackFn - Callback function
+     */
+    forEach(callbackFn) {
+        this.data.forEach((localValue, key, m) => {
+            callbackFn(localValue.value, key, m);
+        });
+    }
+    /**
+     * {@inheritDoc ISharedMap.get}
+     */
+    get(key) {
+        let localValue = this.data.get(key);
+        if (!this.data.has(key)) {
+            localValue = this.createCore(key, true);
+        }
+        return localValue.value;
+    }
+    /**
+     * Check if a key exists in the map.
+     * @param key - The key to check
+     * @returns True if the key exists, false otherwise
+     */
+    has(key) {
+        return this.data.has(key);
+    }
+    /**
+     * Serializes the data stored in the shared map to a JSON string
+     * @param serializer - The serializer to use to serialize handles in its values.
+     * @returns A JSON string containing serialized map data
+     */
+    getSerializedStorage(serializer) {
+        const serializableMapData = {};
+        this.data.forEach((localValue, key) => {
+            serializableMapData[key] = localValue.makeSerialized(serializer, this.handle);
+        });
+        return serializableMapData;
+    }
+    getSerializableStorage(serializer) {
+        const serializableMapData = {};
+        this.data.forEach((localValue, key) => {
+            serializableMapData[key] = (0, localValues_1.makeSerializable)(localValue, serializer, this.handle);
+        });
+        return serializableMapData;
+    }
+    serialize(serializer) {
+        return JSON.stringify(this.getSerializableStorage(serializer));
+    }
+    /**
+     * Populate the kernel with the given map data.
+     * @param data - A JSON string containing serialized map data
+     */
+    populateFromSerializable(json) {
+        for (const [key, serializable] of Object.entries(json)) {
+            // Back-compat: legacy documents may have handles to an intervalCollection map kernel.
+            // These collections should be empty, and ValueTypes are no longer supported.
+            if (serializable.type === shared_object_base_1.ValueType[shared_object_base_1.ValueType.Plain]
+                || serializable.type === shared_object_base_1.ValueType[shared_object_base_1.ValueType.Shared]) {
+                continue;
+            }
+            const localValue = {
+                key,
+                value: this.makeLocal(key, serializable),
+            };
+            this.data.set(localValue.key, localValue.value);
+        }
+    }
+    populate(json) {
+        this.populateFromSerializable(JSON.parse(json));
+    }
+    /**
+     * Submit the given op if a handler is registered.
+     * @param op - The operation to attempt to submit
+     * @param localOpMetadata - The local metadata associated with the op. This is kept locally by the runtime
+     * and not sent to the server. This will be sent back when this message is received back from the server. This is
+     * also sent if we are asked to resubmit the message.
+     * @returns True if the operation was submitted, false otherwise.
+     */
+    trySubmitMessage(op, localOpMetadata) {
+        const type = op.type;
+        const handler = this.messageHandlers.get(type);
+        if (handler !== undefined) {
+            const mapLocalMetadata = localOpMetadata;
+            // we don't know how to rebase these operations, so if any other op has come in
+            // we will fail.
+            if (this.lastProcessedSeq !== (mapLocalMetadata === null || mapLocalMetadata === void 0 ? void 0 : mapLocalMetadata.lastProcessedSeq)) {
+                throw new Error("SharedInterval does not support reconnect in presence of external changes");
+            }
+            handler.submit(op);
+            return true;
+        }
+        return false;
+    }
+    tryGetStashedOpLocalMetadata(op) {
+        const type = op.type;
+        if (this.messageHandlers.has(type)) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            return this.messageHandlers.get(type).getStashedOpLocalMetadata(op);
+        }
+        throw new Error("no apply stashed op handler");
+    }
+    /**
+     * Process the given op if a handler is registered.
+     * @param message - The message 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.
+     * @returns True if the operation was processed, false otherwise.
+     */
+    tryProcessMessage(op, local, message, localOpMetadata) {
+        // track the seq of every incoming message, so we can detect if any
+        // changes happened during a resubmit
+        this.lastProcessedSeq = message.sequenceNumber;
+        const handler = this.messageHandlers.get(op.type);
+        if (handler !== undefined) {
+            handler.process(op, local, message, localOpMetadata);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Initializes a default ValueType at the provided key.
+     * Should be used when a map operation incurs creation.
+     * @param key - The key being initialized
+     * @param local - Whether the message originated from the local client
+     */
+    createCore(key, local) {
+        const localValue = new localValues_1.ValueTypeLocalValue(this.type.factory.load(this.makeMapValueOpEmitter(key), undefined), this.type);
+        const previousValue = this.data.get(key);
+        this.data.set(key, localValue);
+        const event = { key, previousValue };
+        this.eventEmitter.emit("create", event, local, this.eventEmitter);
+        return localValue;
+    }
+    /**
+     * The remote ISerializableValue we're receiving (either as a result of a load or an incoming set op) will
+     * have the information we need to create a real object, but will not be the real object yet.  For example,
+     * we might know it's a map and the map's ID but not have the actual map or its data yet.  makeLocal's
+     * job is to convert that information into a real object for local usage.
+     * @param key - The key that the caller intends to store the local value into (used for ops later).  But
+     * doesn't actually store the local value into that key.  So better not lie!
+     * @param serializable - The remote information that we can convert into a real object
+     * @returns The local value that was produced
+     */
+    makeLocal(key, serializable) {
+        (0, common_utils_1.assert)(serializable.type !== shared_object_base_1.ValueType[shared_object_base_1.ValueType.Plain] && serializable.type !== shared_object_base_1.ValueType[shared_object_base_1.ValueType.Shared], 0x2e1 /* "Support for plain value types removed." */);
+        serializable.value = (0, shared_object_base_1.parseHandles)(serializable.value, this.serializer);
+        const localValue = this.type.factory.load(this.makeMapValueOpEmitter(key), serializable.value);
+        return new localValues_1.ValueTypeLocalValue(localValue, this.type);
+    }
+    /**
+     * Get the message handlers for the map.
+     * @returns A map of string op names to IMapMessageHandlers for those ops
+     */
+    getMessageHandlers() {
+        const messageHandlers = new Map();
+        // Ops with type "act" describe actions taken by custom value type handlers of whatever item is
+        // being addressed.  These custom handlers can be retrieved from the ValueTypeLocalValue which has
+        // stashed its valueType (and therefore its handlers).  We also emit a valueChanged for anyone
+        // watching for manipulations of that item.
+        messageHandlers.set("act", {
+            process: (op, local, message, localOpMetadata) => {
+                var _a;
+                const localValue = (_a = this.data.get(op.key)) !== null && _a !== void 0 ? _a : this.createCore(op.key, local);
+                const handler = localValue.getOpHandler(op.value.opName);
+                const previousValue = localValue.value;
+                const translatedValue = (0, shared_object_base_1.parseHandles)(op.value.value, this.serializer);
+                handler.process(previousValue, translatedValue, local, message);
+                const event = { key: op.key, previousValue };
+                this.eventEmitter.emit("valueChanged", event, local, message, this.eventEmitter);
+            },
+            submit: (op) => {
+                this.submitMessage(op, { lastProcessedSeq: this.lastProcessedSeq });
+            },
+            getStashedOpLocalMetadata: (op) => {
+                (0, common_utils_1.assert)(false, 0x016 /* "apply stashed op not implemented for custom value type ops" */);
+            },
+        });
+        return messageHandlers;
+    }
+    /**
+     * Create an emitter for a value type to emit ops from the given key.
+     * @alpha
+     * @param key - The key of the map that the value type will be stored on
+     * @returns A value op emitter for the given key
+     */
+    makeMapValueOpEmitter(key) {
+        const emit = (opName, previousValue, params) => {
+            const translatedParams = (0, shared_object_base_1.makeHandlesSerializable)(params, this.serializer, this.handle);
+            const op = {
+                key,
+                type: "act",
+                value: {
+                    opName,
+                    value: translatedParams,
+                },
+            };
+            // Send the localOpMetadata as undefined because we don't care about the ack.
+            this.submitMessage(op, { lastProcessedSeq: this.lastProcessedSeq });
+            const event = { key, previousValue };
+            this.eventEmitter.emit("valueChanged", event, true, null, this.eventEmitter);
+        };
+        return { emit };
+    }
+}
+exports.DefaultMap = DefaultMap;
+//# sourceMappingURL=defaultMap.js.map

package/dist/defaultMap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultMap.js","sourceRoot":"","sources":["../src/defaultMap.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { IFluidHandle } from \"@fluidframework/core-interfaces\";\nimport { ISequencedDocumentMessage } from \"@fluidframework/protocol-definitions\";\nimport {\n    IFluidSerializer,\n    makeHandlesSerializable,\n    parseHandles,\n    ValueType,\n} from \"@fluidframework/shared-object-base\";\nimport { assert, TypedEventEmitter } from \"@fluidframework/common-utils\";\nimport {\n    makeSerializable,\n    ValueTypeLocalValue,\n} from \"./localValues\";\nimport {\n    ISerializableValue,\n    ISerializedValue,\n    IValueChanged,\n    IValueOpEmitter,\n    IValueType,\n    IValueTypeOperationValue,\n    ISharedDefaultMapEvents,\n} from \"./defaultMapInterfaces\";\n\n/**\n * Defines the means to process and submit a given op on a map.\n */\ninterface IMapMessageHandler {\n    /**\n     * Apply the given operation.\n     * @param op - The map operation to apply\n     * @param local - Whether the message originated from the local client\n     * @param message - The full message. Not provided for stashed ops.\n     * @param localOpMetadata - For local client messages, this is the metadata that was submitted with the message.\n     * For messages from a remote client, this will be undefined.\n     */\n    process(\n        op: IMapOperation,\n        local: boolean,\n        message: ISequencedDocumentMessage | undefined,\n        localOpMetadata: IMapMessageLocalMetadata,\n    ): void;\n\n    /**\n     * Communicate the operation to remote clients.\n     * @param op - The map operation to submit\n     */\n    submit(op: IMapOperation): void;\n\n    getStashedOpLocalMetadata(op: IMapOperation): unknown;\n}\n\nexport interface IMapMessageLocalMetadata {\n    lastProcessedSeq: number;\n}\n\n/**\n * Describes an operation specific to a value type.\n */\nexport interface IMapValueTypeOperation {\n    /**\n     * String identifier of the operation type.\n     */\n    type: \"act\";\n\n    /**\n     * Map key being modified.\n     */\n    key: string;\n\n    /**\n     * Value of the operation, specific to the value type.\n     * @alpha\n     */\n    value: IValueTypeOperationValue;\n}\n\n/**\n * Description of a map delta operation\n */\nexport type IMapOperation = IMapValueTypeOperation;\n\n/**\n * Defines the in-memory object structure to be used for the conversion to/from serialized.\n * Directly used in JSON.stringify, direct result from JSON.parse\n */\nexport interface IMapDataObjectSerializable {\n    [key: string]: ISerializableValue;\n}\n\nexport interface IMapDataObjectSerialized {\n    [key: string]: ISerializedValue;\n}\n\n/**\n * A DefaultMap is a map-like distributed data structure, supporting operations on values stored by\n * string key locations.\n *\n * Creation of values is implicit on access (either via `get` or a remote op application referring to\n * a collection that wasn't previously known)\n */\nexport class DefaultMap<T> {\n    /**\n     * The number of key/value pairs stored in the map.\n     */\n    public get size(): number {\n        return this.data.size;\n    }\n\n    /**\n     * Mapping of op types to message handlers.\n     */\n    private readonly messageHandlers: ReadonlyMap<string, IMapMessageHandler> = new Map();\n\n    /**\n     * The in-memory data the map is storing.\n     */\n    private readonly data = new Map<string, ValueTypeLocalValue<T>>();\n\n    private lastProcessedSeq: number = -1;\n\n    /**\n     * Create a new default map.\n     * @param serializer - The serializer to serialize / parse handles\n     * @param handle - The handle of the shared object using the kernel\n     * @param submitMessage - A callback to submit a message through the shared object\n     * @param type - The value type to create at values of this map\n     * @param eventEmitter - The object that will emit map events\n     */\n    constructor(\n        private readonly serializer: IFluidSerializer,\n        private readonly handle: IFluidHandle,\n        private readonly submitMessage: (op: any, localOpMetadata: IMapMessageLocalMetadata) => void,\n        private readonly type: IValueType<T>,\n        public readonly eventEmitter = new TypedEventEmitter<ISharedDefaultMapEvents>(),\n    ) {\n        this.messageHandlers = this.getMessageHandlers();\n    }\n\n    /**\n     * Get an iterator over the keys in this map.\n     * @returns The iterator\n     */\n    public keys(): IterableIterator<string> {\n        return this.data.keys();\n    }\n\n    /**\n     * Get an iterator over the entries in this map.\n     * @returns The iterator\n     */\n    public entries(): IterableIterator<[string, any]> {\n        const localEntriesIterator = this.data.entries();\n        const iterator = {\n            next(): IteratorResult<[string, any]> {\n                const nextVal = localEntriesIterator.next();\n                if (nextVal.done) {\n                    return { value: undefined, done: true };\n                } else {\n                    // Unpack the stored value\n                    return { value: [nextVal.value[0], nextVal.value[1].value], done: false };\n                }\n            },\n            [Symbol.iterator]() {\n                return this;\n            },\n        };\n        return iterator;\n    }\n\n    /**\n     * Get an iterator over the values in this map.\n     * @returns The iterator\n     */\n    public values(): IterableIterator<any> {\n        const localValuesIterator = this.data.values();\n        const iterator = {\n            next(): IteratorResult<any> {\n                const nextVal = localValuesIterator.next();\n                if (nextVal.done) {\n                    return { value: undefined, done: true };\n                } else {\n                    // Unpack the stored value\n                    return { value: nextVal.value.value, done: false };\n                }\n            },\n            [Symbol.iterator]() {\n                return this;\n            },\n        };\n        return iterator;\n    }\n\n    /**\n     * Get an iterator over the entries in this map.\n     * @returns The iterator\n     */\n    public [Symbol.iterator](): IterableIterator<[string, any]> {\n        return this.entries();\n    }\n\n    /**\n     * Executes the given callback on each entry in the map.\n     * @param callbackFn - Callback function\n     */\n    public forEach(callbackFn: (value: any, key: string, map: Map<string, any>) => void): void {\n        this.data.forEach((localValue, key, m) => {\n            callbackFn(localValue.value, key, m);\n        });\n    }\n\n    /**\n     * {@inheritDoc ISharedMap.get}\n     */\n    public get(key: string): T {\n        let localValue = this.data.get(key);\n        if (!this.data.has(key)) {\n            localValue = this.createCore(key, true);\n        }\n        return localValue.value;\n    }\n\n    /**\n     * Check if a key exists in the map.\n     * @param key - The key to check\n     * @returns True if the key exists, false otherwise\n     */\n    public has(key: string): boolean {\n        return this.data.has(key);\n    }\n\n    /**\n     * Serializes the data stored in the shared map to a JSON string\n     * @param serializer - The serializer to use to serialize handles in its values.\n     * @returns A JSON string containing serialized map data\n     */\n    public getSerializedStorage(serializer: IFluidSerializer): IMapDataObjectSerialized {\n        const serializableMapData: IMapDataObjectSerialized = {};\n        this.data.forEach((localValue, key) => {\n            serializableMapData[key] = localValue.makeSerialized(serializer, this.handle);\n        });\n        return serializableMapData;\n    }\n\n    public getSerializableStorage(serializer: IFluidSerializer): IMapDataObjectSerializable {\n        const serializableMapData: IMapDataObjectSerializable = {};\n        this.data.forEach((localValue, key) => {\n            serializableMapData[key] = makeSerializable(localValue, serializer, this.handle);\n        });\n        return serializableMapData;\n    }\n\n    public serialize(serializer: IFluidSerializer): string {\n        return JSON.stringify(this.getSerializableStorage(serializer));\n    }\n\n    /**\n     * Populate the kernel with the given map data.\n     * @param data - A JSON string containing serialized map data\n     */\n    public populateFromSerializable(json: IMapDataObjectSerializable): void {\n        for (const [key, serializable] of Object.entries(json)) {\n            // Back-compat: legacy documents may have handles to an intervalCollection map kernel.\n            // These collections should be empty, and ValueTypes are no longer supported.\n            if (serializable.type === ValueType[ValueType.Plain]\n                || serializable.type === ValueType[ValueType.Shared]) {\n                continue;\n            }\n\n            const localValue = {\n                key,\n                value: this.makeLocal(key, serializable),\n            };\n\n            this.data.set(localValue.key, localValue.value);\n        }\n    }\n\n    public populate(json: string): void {\n        this.populateFromSerializable(JSON.parse(json) as IMapDataObjectSerializable);\n    }\n\n    /**\n     * Submit the given op if a handler is registered.\n     * @param op - The operation to attempt to submit\n     * @param localOpMetadata - The local metadata associated with the op. This is kept locally by the runtime\n     * and not sent to the server. This will be sent back when this message is received back from the server. This is\n     * also sent if we are asked to resubmit the message.\n     * @returns True if the operation was submitted, false otherwise.\n     */\n    public trySubmitMessage(op: any, localOpMetadata: IMapMessageLocalMetadata): boolean {\n        const type: string = op.type;\n        const handler = this.messageHandlers.get(type);\n        if (handler !== undefined) {\n            const mapLocalMetadata: Partial<IMapMessageLocalMetadata> = localOpMetadata;\n            // we don't know how to rebase these operations, so if any other op has come in\n            // we will fail.\n            if (this.lastProcessedSeq !== mapLocalMetadata?.lastProcessedSeq) {\n                throw new Error(\"SharedInterval does not support reconnect in presence of external changes\");\n            }\n            handler.submit(op as IMapOperation);\n            return true;\n        }\n        return false;\n    }\n\n    public tryGetStashedOpLocalMetadata(op: any): unknown {\n        const type: string = op.type;\n        if (this.messageHandlers.has(type)) {\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n            return this.messageHandlers.get(type)!.getStashedOpLocalMetadata(op as IMapOperation);\n        }\n        throw new Error(\"no apply stashed op handler\");\n    }\n\n    /**\n     * Process the given op if a handler is registered.\n     * @param message - The message to process\n     * @param local - Whether the message originated from the local client\n     * @param localOpMetadata - For local client messages, this is the metadata that was submitted with the message.\n     * For messages from a remote client, this will be undefined.\n     * @returns True if the operation was processed, false otherwise.\n     */\n    public tryProcessMessage(\n        op: IMapOperation,\n        local: boolean,\n        message: ISequencedDocumentMessage | undefined,\n        localOpMetadata: unknown,\n    ): boolean {\n        // track the seq of every incoming message, so we can detect if any\n        // changes happened during a resubmit\n        this.lastProcessedSeq = message.sequenceNumber;\n        const handler = this.messageHandlers.get(op.type);\n        if (handler !== undefined) {\n            handler.process(op, local, message, localOpMetadata as IMapMessageLocalMetadata);\n            return true;\n        }\n        return false;\n    }\n\n    /**\n     * Initializes a default ValueType at the provided key.\n     * Should be used when a map operation incurs creation.\n     * @param key - The key being initialized\n     * @param local - Whether the message originated from the local client\n     */\n    private createCore(key: string, local: boolean): ValueTypeLocalValue<T> {\n        const localValue = new ValueTypeLocalValue(\n            this.type.factory.load(this.makeMapValueOpEmitter(key), undefined),\n            this.type,\n        );\n        const previousValue = this.data.get(key);\n        this.data.set(key, localValue);\n        const event: IValueChanged = { key, previousValue };\n        this.eventEmitter.emit(\"create\", event, local, this.eventEmitter);\n        return localValue;\n    }\n\n    /**\n     * The remote ISerializableValue we're receiving (either as a result of a load or an incoming set op) will\n     * have the information we need to create a real object, but will not be the real object yet.  For example,\n     * we might know it's a map and the map's ID but not have the actual map or its data yet.  makeLocal's\n     * job is to convert that information into a real object for local usage.\n     * @param key - The key that the caller intends to store the local value into (used for ops later).  But\n     * doesn't actually store the local value into that key.  So better not lie!\n     * @param serializable - The remote information that we can convert into a real object\n     * @returns The local value that was produced\n     */\n    private makeLocal(key: string, serializable: ISerializableValue): ValueTypeLocalValue<T> {\n        assert(serializable.type !== ValueType[ValueType.Plain] && serializable.type !== ValueType[ValueType.Shared],\n            0x2e1 /* \"Support for plain value types removed.\" */);\n\n        serializable.value = parseHandles(serializable.value, this.serializer);\n        const localValue = this.type.factory.load(\n            this.makeMapValueOpEmitter(key),\n            serializable.value,\n        );\n        return new ValueTypeLocalValue(localValue, this.type);\n    }\n\n    /**\n     * Get the message handlers for the map.\n     * @returns A map of string op names to IMapMessageHandlers for those ops\n     */\n    private getMessageHandlers() {\n        const messageHandlers = new Map<string, IMapMessageHandler>();\n        // Ops with type \"act\" describe actions taken by custom value type handlers of whatever item is\n        // being addressed.  These custom handlers can be retrieved from the ValueTypeLocalValue which has\n        // stashed its valueType (and therefore its handlers).  We also emit a valueChanged for anyone\n        // watching for manipulations of that item.\n        messageHandlers.set(\n            \"act\",\n            {\n                process: (op: IMapValueTypeOperation, local, message, localOpMetadata) => {\n                    const localValue = this.data.get(op.key) ?? this.createCore(op.key, local);\n                    const handler = localValue.getOpHandler(op.value.opName);\n                    const previousValue = localValue.value;\n                    const translatedValue = parseHandles(\n                        op.value.value,\n                        this.serializer);\n                    handler.process(previousValue, translatedValue, local, message);\n                    const event: IValueChanged = { key: op.key, previousValue };\n                    this.eventEmitter.emit(\"valueChanged\", event, local, message, this.eventEmitter);\n                },\n                submit: (op: IMapValueTypeOperation) => {\n                    this.submitMessage(\n                        op,\n                        { lastProcessedSeq: this.lastProcessedSeq },\n                    );\n                },\n                getStashedOpLocalMetadata: (op: IMapValueTypeOperation) => {\n                    assert(false, 0x016 /* \"apply stashed op not implemented for custom value type ops\" */);\n                },\n            });\n\n        return messageHandlers;\n    }\n\n    /**\n     * Create an emitter for a value type to emit ops from the given key.\n     * @alpha\n     * @param key - The key of the map that the value type will be stored on\n     * @returns A value op emitter for the given key\n     */\n    private makeMapValueOpEmitter(key: string): IValueOpEmitter {\n        const emit = (opName: string, previousValue: any, params: any) => {\n            const translatedParams = makeHandlesSerializable(\n                params,\n                this.serializer,\n                this.handle);\n\n            const op: IMapValueTypeOperation = {\n                key,\n                type: \"act\",\n                value: {\n                    opName,\n                    value: translatedParams,\n                },\n            };\n            // Send the localOpMetadata as undefined because we don't care about the ack.\n            this.submitMessage(op, { lastProcessedSeq: this.lastProcessedSeq });\n\n            const event: IValueChanged = { key, previousValue };\n            this.eventEmitter.emit(\"valueChanged\", event, true, null, this.eventEmitter);\n        };\n\n        return { emit };\n    }\n}\n"]}