@azure/event-hubs 6.0.2-alpha.20251014.1 → 6.0.2-alpha.20251021.1

package/dist/react-native/inMemoryCheckpointStore.js

@@ -0,0 +1,94 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { throwTypeErrorIfParameterMissing } from "./util/error.js";
+import { getRandomName } from "./util/utils.js";
+/**
+ * The `EventProcessor` relies on a `CheckpointStore` to store checkpoints and handle partition
+ * ownerships. `InMemoryCheckpointStore` is simple partition manager that stores checkpoints and
+ * partition ownerships in memory of your program.
+ *
+ * You can use the `InMemoryCheckpointStore` to get started with using the `EventProcessor`.
+ * But in production, you should choose an implementation of the `CheckpointStore` interface that will
+ * store the checkpoints and partition ownerships to a durable store instead.
+ *
+ * @internal
+ */
+export class InMemoryCheckpointStore {
+    _partitionOwnershipMap = new Map();
+    _committedCheckpoints = new Map();
+    /**
+     * Get the list of all existing partition ownership from the underlying data store. Could return empty
+     * results if there are is no existing ownership information.
+     *
+     * @param fullyQualifiedNamespace - The fully qualified Event Hubs namespace. This is likely to be similar to
+     * <yournamespace>.servicebus.windows.net.
+     * @param eventHubName - The event hub name.
+     * @param consumerGroup - The consumer group name.
+     * @returns Partition ownership details of all the partitions that have/had an owner..
+     */
+    async listOwnership(_fullyQualifiedNamespace, _eventHubName, _consumerGroup) {
+        const ownerships = [];
+        for (const value of this._partitionOwnershipMap.values()) {
+            ownerships.push({ ...value });
+        }
+        return ownerships;
+    }
+    /**
+     * Claim ownership of a list of partitions. This will return the list of partitions that were owned
+     * successfully.
+     *
+     * @param partitionOwnership - The list of partition ownership this instance is claiming to own.
+     * @returns A list partitions this instance successfully claimed ownership.
+     */
+    async claimOwnership(partitionOwnership) {
+        const claimedOwnerships = [];
+        for (const ownership of partitionOwnership) {
+            if (!this._partitionOwnershipMap.has(ownership.partitionId) ||
+                this._partitionOwnershipMap.get(ownership.partitionId).etag === ownership.etag) {
+                const date = new Date();
+                const newOwnership = {
+                    ...ownership,
+                    etag: getRandomName(),
+                    lastModifiedTimeInMs: date.getTime(),
+                };
+                this._partitionOwnershipMap.set(newOwnership.partitionId, newOwnership);
+                claimedOwnerships.push(newOwnership);
+            }
+        }
+        return claimedOwnerships;
+    }
+    /**
+     * Updates the checkpoint in the data store for a partition.
+     *
+     * @param checkpoint - The checkpoint.
+     */
+    async updateCheckpoint(checkpoint) {
+        throwTypeErrorIfParameterMissing("", "updateCheckpoint", "sequenceNumber", checkpoint.sequenceNumber);
+        throwTypeErrorIfParameterMissing("", "updateCheckpoint", "offset", checkpoint.offset);
+        checkpoint = { ...checkpoint };
+        const partitionOwnership = this._partitionOwnershipMap.get(checkpoint.partitionId);
+        if (partitionOwnership) {
+            partitionOwnership.etag = getRandomName();
+            const key = `${checkpoint.fullyQualifiedNamespace}:${checkpoint.eventHubName}:${checkpoint.consumerGroup}`;
+            let partitionMap = this._committedCheckpoints.get(key);
+            if (partitionMap == null) {
+                partitionMap = new Map();
+                this._committedCheckpoints.set(key, partitionMap);
+            }
+            partitionMap.set(checkpoint.partitionId, checkpoint);
+        }
+    }
+    async listCheckpoints(fullyQualifiedNamespace, eventHubName, consumerGroup) {
+        const key = `${fullyQualifiedNamespace}:${eventHubName}:${consumerGroup}`;
+        const partitionMap = this._committedCheckpoints.get(key);
+        if (partitionMap == null) {
+            return [];
+        }
+        const checkpoints = [];
+        for (const value of partitionMap.values()) {
+            checkpoints.push({ ...value });
+        }
+        return checkpoints;
+    }
+}
+//# sourceMappingURL=inMemoryCheckpointStore.js.map

package/dist/react-native/inMemoryCheckpointStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inMemoryCheckpointStore.js","sourceRoot":"","sources":["../../src/inMemoryCheckpointStore.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type { CheckpointStore, PartitionOwnership } from \"./eventProcessor.js\";\nimport type { Checkpoint } from \"./partitionProcessor.js\";\nimport { throwTypeErrorIfParameterMissing } from \"./util/error.js\";\nimport { getRandomName } from \"./util/utils.js\";\n\n/**\n * The `EventProcessor` relies on a `CheckpointStore` to store checkpoints and handle partition\n * ownerships. `InMemoryCheckpointStore` is simple partition manager that stores checkpoints and\n * partition ownerships in memory of your program.\n *\n * You can use the `InMemoryCheckpointStore` to get started with using the `EventProcessor`.\n * But in production, you should choose an implementation of the `CheckpointStore` interface that will\n * store the checkpoints and partition ownerships to a durable store instead.\n *\n * @internal\n */\nexport class InMemoryCheckpointStore implements CheckpointStore {\n  private _partitionOwnershipMap: Map<string, PartitionOwnership> = new Map();\n  private _committedCheckpoints: Map<string, Map<string, Checkpoint>> = new Map();\n\n  /**\n   * Get the list of all existing partition ownership from the underlying data store. Could return empty\n   * results if there are is no existing ownership information.\n   *\n   * @param fullyQualifiedNamespace - The fully qualified Event Hubs namespace. This is likely to be similar to\n   * <yournamespace>.servicebus.windows.net.\n   * @param eventHubName - The event hub name.\n   * @param consumerGroup - The consumer group name.\n   * @returns Partition ownership details of all the partitions that have/had an owner..\n   */\n  async listOwnership(\n    _fullyQualifiedNamespace: string,\n    _eventHubName: string,\n    _consumerGroup: string,\n  ): Promise<PartitionOwnership[]> {\n    const ownerships = [];\n\n    for (const value of this._partitionOwnershipMap.values()) {\n      ownerships.push({ ...value });\n    }\n\n    return ownerships;\n  }\n\n  /**\n   * Claim ownership of a list of partitions. This will return the list of partitions that were owned\n   * successfully.\n   *\n   * @param partitionOwnership - The list of partition ownership this instance is claiming to own.\n   * @returns A list partitions this instance successfully claimed ownership.\n   */\n  async claimOwnership(partitionOwnership: PartitionOwnership[]): Promise<PartitionOwnership[]> {\n    const claimedOwnerships = [];\n\n    for (const ownership of partitionOwnership) {\n      if (\n        !this._partitionOwnershipMap.has(ownership.partitionId) ||\n        this._partitionOwnershipMap.get(ownership.partitionId)!.etag === ownership.etag\n      ) {\n        const date = new Date();\n\n        const newOwnership = {\n          ...ownership,\n          etag: getRandomName(),\n          lastModifiedTimeInMs: date.getTime(),\n        };\n\n        this._partitionOwnershipMap.set(newOwnership.partitionId, newOwnership);\n        claimedOwnerships.push(newOwnership);\n      }\n    }\n    return claimedOwnerships;\n  }\n\n  /**\n   * Updates the checkpoint in the data store for a partition.\n   *\n   * @param checkpoint - The checkpoint.\n   */\n  async updateCheckpoint(checkpoint: Checkpoint): Promise<void> {\n    throwTypeErrorIfParameterMissing(\n      \"\",\n      \"updateCheckpoint\",\n      \"sequenceNumber\",\n      checkpoint.sequenceNumber,\n    );\n    throwTypeErrorIfParameterMissing(\"\", \"updateCheckpoint\", \"offset\", checkpoint.offset);\n\n    checkpoint = { ...checkpoint };\n\n    const partitionOwnership = this._partitionOwnershipMap.get(checkpoint.partitionId);\n    if (partitionOwnership) {\n      partitionOwnership.etag = getRandomName();\n\n      const key = `${checkpoint.fullyQualifiedNamespace}:${checkpoint.eventHubName}:${checkpoint.consumerGroup}`;\n      let partitionMap = this._committedCheckpoints.get(key);\n\n      if (partitionMap == null) {\n        partitionMap = new Map();\n        this._committedCheckpoints.set(key, partitionMap);\n      }\n\n      partitionMap.set(checkpoint.partitionId, checkpoint);\n    }\n  }\n\n  async listCheckpoints(\n    fullyQualifiedNamespace: string,\n    eventHubName: string,\n    consumerGroup: string,\n  ): Promise<Checkpoint[]> {\n    const key = `${fullyQualifiedNamespace}:${eventHubName}:${consumerGroup}`;\n\n    const partitionMap = this._committedCheckpoints.get(key);\n\n    if (partitionMap == null) {\n      return [];\n    }\n\n    const checkpoints = [];\n\n    for (const value of partitionMap.values()) {\n      checkpoints.push({ ...value });\n    }\n\n    return checkpoints;\n  }\n}\n"]}

package/dist/react-native/index.d.ts

@@ -0,0 +1,21 @@
+export { EventData, ReceivedEventData } from "./eventData.js";
+export { WebSocketImpl } from "rhea-promise";
+export { LastEnqueuedEventProperties } from "./partitionReceiver.js";
+export { OperationOptions } from "./util/operationOptions.js";
+export { EventHubClientOptions, EventHubConsumerClientOptions, LoadBalancingOptions, SendBatchOptions, CreateBatchOptions, GetPartitionIdsOptions, GetPartitionPropertiesOptions, GetEventHubPropertiesOptions, } from "./models/public.js";
+export { EventHubConsumerClient } from "./eventHubConsumerClient.js";
+export { EventHubProducerClient } from "./eventHubProducerClient.js";
+export { BufferedCloseOptions, EventHubBufferedProducerClient, EventHubBufferedProducerClientOptions, EnqueueEventOptions, BufferedFlushOptions, OnSendEventsErrorContext, OnSendEventsSuccessContext, } from "./eventHubBufferedProducerClient.js";
+export { SubscribeOptions, Subscription, SubscriptionEventHandlers, PartitionContext, ProcessErrorHandler, ProcessInitializeHandler, ProcessCloseHandler, ProcessEventsHandler, } from "./eventHubConsumerClientModels.js";
+export { EventPosition, latestEventPosition, earliestEventPosition } from "./eventPosition.js";
+export { PartitionProperties, EventHubProperties } from "./managementClient.js";
+export { EventDataBatch, TryAddOptions } from "./eventDataBatch.js";
+export { Checkpoint } from "./partitionProcessor.js";
+export { CheckpointStore, PartitionOwnership } from "./eventProcessor.js";
+export { CloseReason } from "./models/public.js";
+export { MessagingError, RetryOptions, RetryMode, WebSocketOptions } from "@azure/core-amqp";
+export { TokenCredential } from "@azure/core-auth";
+export { logger } from "./logger.js";
+export { parseEventHubConnectionString, EventHubConnectionStringProperties, } from "./util/connectionStringUtils.js";
+export * from "./eventDataAdapter.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/react-native/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAC9D,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAC;AACrE,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,EACL,qBAAqB,EACrB,6BAA6B,EAC7B,oBAAoB,EACpB,gBAAgB,EAChB,kBAAkB,EAClB,sBAAsB,EACtB,6BAA6B,EAC7B,4BAA4B,GAC7B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AACrE,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AACrE,OAAO,EACL,oBAAoB,EACpB,8BAA8B,EAC9B,qCAAqC,EACrC,mBAAmB,EACnB,oBAAoB,EACpB,wBAAwB,EACxB,0BAA0B,GAC3B,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EACL,gBAAgB,EAChB,YAAY,EACZ,yBAAyB,EACzB,gBAAgB,EAChB,mBAAmB,EACnB,wBAAwB,EACxB,mBAAmB,EACnB,oBAAoB,GACrB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAE,aAAa,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAC/F,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAChF,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpE,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AACrD,OAAO,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAC1E,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAC7F,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EACL,6BAA6B,EAC7B,kCAAkC,GACnC,MAAM,iCAAiC,CAAC;AAEzC,cAAc,uBAAuB,CAAC"}

package/dist/react-native/index.js

@@ -0,0 +1,12 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+export { EventHubConsumerClient } from "./eventHubConsumerClient.js";
+export { EventHubProducerClient } from "./eventHubProducerClient.js";
+export { EventHubBufferedProducerClient, } from "./eventHubBufferedProducerClient.js";
+export { latestEventPosition, earliestEventPosition } from "./eventPosition.js";
+export { CloseReason } from "./models/public.js";
+export { MessagingError, RetryMode } from "@azure/core-amqp";
+export { logger } from "./logger.js";
+export { parseEventHubConnectionString, } from "./util/connectionStringUtils.js";
+export * from "./eventDataAdapter.js";
+//# sourceMappingURL=index.js.map

package/dist/react-native/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,kCAAkC;AAgBlC,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AACrE,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AACrE,OAAO,EAEL,8BAA8B,GAM/B,MAAM,qCAAqC,CAAC;AAW7C,OAAO,EAAiB,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAK/F,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,cAAc,EAAgB,SAAS,EAAoB,MAAM,kBAAkB,CAAC;AAE7F,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EACL,6BAA6B,GAE9B,MAAM,iCAAiC,CAAC;AAEzC,cAAc,uBAAuB,CAAC","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nexport { EventData, ReceivedEventData } from \"./eventData.js\";\nexport { WebSocketImpl } from \"rhea-promise\";\nexport { LastEnqueuedEventProperties } from \"./partitionReceiver.js\";\nexport { OperationOptions } from \"./util/operationOptions.js\";\nexport {\n  EventHubClientOptions,\n  EventHubConsumerClientOptions,\n  LoadBalancingOptions,\n  SendBatchOptions,\n  CreateBatchOptions,\n  GetPartitionIdsOptions,\n  GetPartitionPropertiesOptions,\n  GetEventHubPropertiesOptions,\n} from \"./models/public.js\";\nexport { EventHubConsumerClient } from \"./eventHubConsumerClient.js\";\nexport { EventHubProducerClient } from \"./eventHubProducerClient.js\";\nexport {\n  BufferedCloseOptions,\n  EventHubBufferedProducerClient,\n  EventHubBufferedProducerClientOptions,\n  EnqueueEventOptions,\n  BufferedFlushOptions,\n  OnSendEventsErrorContext,\n  OnSendEventsSuccessContext,\n} from \"./eventHubBufferedProducerClient.js\";\nexport {\n  SubscribeOptions,\n  Subscription,\n  SubscriptionEventHandlers,\n  PartitionContext,\n  ProcessErrorHandler,\n  ProcessInitializeHandler,\n  ProcessCloseHandler,\n  ProcessEventsHandler,\n} from \"./eventHubConsumerClientModels.js\";\nexport { EventPosition, latestEventPosition, earliestEventPosition } from \"./eventPosition.js\";\nexport { PartitionProperties, EventHubProperties } from \"./managementClient.js\";\nexport { EventDataBatch, TryAddOptions } from \"./eventDataBatch.js\";\nexport { Checkpoint } from \"./partitionProcessor.js\";\nexport { CheckpointStore, PartitionOwnership } from \"./eventProcessor.js\";\nexport { CloseReason } from \"./models/public.js\";\nexport { MessagingError, RetryOptions, RetryMode, WebSocketOptions } from \"@azure/core-amqp\";\nexport { TokenCredential } from \"@azure/core-auth\";\nexport { logger } from \"./logger.js\";\nexport {\n  parseEventHubConnectionString,\n  EventHubConnectionStringProperties,\n} from \"./util/connectionStringUtils.js\";\n\nexport * from \"./eventDataAdapter.js\";\n"]}

package/dist/react-native/loadBalancerStrategies/balancedStrategy.d.ts

@@ -0,0 +1,30 @@
+import type { LoadBalancingStrategy } from "./loadBalancingStrategy.js";
+import type { PartitionOwnership } from "../eventProcessor.js";
+/**
+ * The BalancedLoadBalancerStrategy is meant to be used when the user
+ * wants to reach a load balanced state with less partition 'thrashing'.
+ *
+ * Partition thrashing - where a partition changes owners - is minimized
+ * by only returning a single partition to claim at a time.
+ * This minimizes the number of times a partition should need to be stolen.
+ * @internal
+ */
+export declare class BalancedLoadBalancingStrategy implements LoadBalancingStrategy {
+    private readonly _partitionOwnershipExpirationIntervalInMs;
+    /**
+     * Creates an instance of BalancedLoadBalancingStrategy.
+     *
+     * @param _partitionOwnershipExpirationIntervalInMs - The length of time a partition claim is valid.
+     */
+    constructor(_partitionOwnershipExpirationIntervalInMs: number);
+    /**
+     * Implements load balancing by taking into account current ownership and
+     * the full set of partitions in the Event Hub.
+     * @param ourOwnerId - The id we should assume is _our_ id when checking for ownership.
+     * @param claimedPartitionOwnershipMap - The current claimed ownerships for partitions.
+     * @param partitionIds - Partitions to assign owners to.
+     * @returns Partition ids to claim.
+     */
+    getPartitionsToClaim(ourOwnerId: string, claimedPartitionOwnershipMap: Map<string, PartitionOwnership>, partitionIds: string[]): string[];
+}
+//# sourceMappingURL=balancedStrategy.d.ts.map

package/dist/react-native/loadBalancerStrategies/balancedStrategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"balancedStrategy.d.ts","sourceRoot":"","sources":["../../../src/loadBalancerStrategies/balancedStrategy.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAExE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE/D;;;;;;;;GAQG;AACH,qBAAa,6BAA8B,YAAW,qBAAqB;IAM7D,OAAO,CAAC,QAAQ,CAAC,yCAAyC;IALtE;;;;OAIG;gBAC0B,yCAAyC,EAAE,MAAM;IAE9E;;;;;;;OAOG;IACI,oBAAoB,CACzB,UAAU,EAAE,MAAM,EAClB,4BAA4B,EAAE,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,EAC7D,YAAY,EAAE,MAAM,EAAE,GACrB,MAAM,EAAE;CAeZ"}

package/dist/react-native/loadBalancerStrategies/balancedStrategy.js

@@ -0,0 +1,40 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { listAvailablePartitions } from "./loadBalancingStrategy.js";
+/**
+ * The BalancedLoadBalancerStrategy is meant to be used when the user
+ * wants to reach a load balanced state with less partition 'thrashing'.
+ *
+ * Partition thrashing - where a partition changes owners - is minimized
+ * by only returning a single partition to claim at a time.
+ * This minimizes the number of times a partition should need to be stolen.
+ * @internal
+ */
+export class BalancedLoadBalancingStrategy {
+    _partitionOwnershipExpirationIntervalInMs;
+    /**
+     * Creates an instance of BalancedLoadBalancingStrategy.
+     *
+     * @param _partitionOwnershipExpirationIntervalInMs - The length of time a partition claim is valid.
+     */
+    constructor(_partitionOwnershipExpirationIntervalInMs) {
+        this._partitionOwnershipExpirationIntervalInMs = _partitionOwnershipExpirationIntervalInMs;
+    }
+    /**
+     * Implements load balancing by taking into account current ownership and
+     * the full set of partitions in the Event Hub.
+     * @param ourOwnerId - The id we should assume is _our_ id when checking for ownership.
+     * @param claimedPartitionOwnershipMap - The current claimed ownerships for partitions.
+     * @param partitionIds - Partitions to assign owners to.
+     * @returns Partition ids to claim.
+     */
+    getPartitionsToClaim(ourOwnerId, claimedPartitionOwnershipMap, partitionIds) {
+        const claimablePartitions = listAvailablePartitions(ourOwnerId, claimedPartitionOwnershipMap, partitionIds, this._partitionOwnershipExpirationIntervalInMs);
+        if (!claimablePartitions.length) {
+            return [];
+        }
+        const randomIndex = Math.floor(Math.random() * claimablePartitions.length);
+        return [claimablePartitions[randomIndex]];
+    }
+}
+//# sourceMappingURL=balancedStrategy.js.map

package/dist/react-native/loadBalancerStrategies/balancedStrategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"balancedStrategy.js","sourceRoot":"","sources":["../../../src/loadBalancerStrategies/balancedStrategy.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,kCAAkC;AAGlC,OAAO,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AAGrE;;;;;;;;GAQG;AACH,MAAM,OAAO,6BAA6B;IAMX;IAL7B;;;;OAIG;IACH,YAA6B,yCAAiD;QAAjD,8CAAyC,GAAzC,yCAAyC,CAAQ;IAAG,CAAC;IAElF;;;;;;;OAOG;IACI,oBAAoB,CACzB,UAAkB,EAClB,4BAA6D,EAC7D,YAAsB;QAEtB,MAAM,mBAAmB,GAAG,uBAAuB,CACjD,UAAU,EACV,4BAA4B,EAC5B,YAAY,EACZ,IAAI,CAAC,yCAAyC,CAC/C,CAAC;QAEF,IAAI,CAAC,mBAAmB,CAAC,MAAM,EAAE,CAAC;YAChC,OAAO,EAAE,CAAC;QACZ,CAAC;QAED,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,mBAAmB,CAAC,MAAM,CAAC,CAAC;QAC3E,OAAO,CAAC,mBAAmB,CAAC,WAAW,CAAC,CAAC,CAAC;IAC5C,CAAC;CACF","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type { LoadBalancingStrategy } from \"./loadBalancingStrategy.js\";\nimport { listAvailablePartitions } from \"./loadBalancingStrategy.js\";\nimport type { PartitionOwnership } from \"../eventProcessor.js\";\n\n/**\n * The BalancedLoadBalancerStrategy is meant to be used when the user\n * wants to reach a load balanced state with less partition 'thrashing'.\n *\n * Partition thrashing - where a partition changes owners - is minimized\n * by only returning a single partition to claim at a time.\n * This minimizes the number of times a partition should need to be stolen.\n * @internal\n */\nexport class BalancedLoadBalancingStrategy implements LoadBalancingStrategy {\n  /**\n   * Creates an instance of BalancedLoadBalancingStrategy.\n   *\n   * @param _partitionOwnershipExpirationIntervalInMs - The length of time a partition claim is valid.\n   */\n  constructor(private readonly _partitionOwnershipExpirationIntervalInMs: number) {}\n\n  /**\n   * Implements load balancing by taking into account current ownership and\n   * the full set of partitions in the Event Hub.\n   * @param ourOwnerId - The id we should assume is _our_ id when checking for ownership.\n   * @param claimedPartitionOwnershipMap - The current claimed ownerships for partitions.\n   * @param partitionIds - Partitions to assign owners to.\n   * @returns Partition ids to claim.\n   */\n  public getPartitionsToClaim(\n    ourOwnerId: string,\n    claimedPartitionOwnershipMap: Map<string, PartitionOwnership>,\n    partitionIds: string[],\n  ): string[] {\n    const claimablePartitions = listAvailablePartitions(\n      ourOwnerId,\n      claimedPartitionOwnershipMap,\n      partitionIds,\n      this._partitionOwnershipExpirationIntervalInMs,\n    );\n\n    if (!claimablePartitions.length) {\n      return [];\n    }\n\n    const randomIndex = Math.floor(Math.random() * claimablePartitions.length);\n    return [claimablePartitions[randomIndex]];\n  }\n}\n"]}

package/dist/react-native/loadBalancerStrategies/greedyStrategy.d.ts

@@ -0,0 +1,24 @@
+import type { LoadBalancingStrategy } from "./loadBalancingStrategy.js";
+import type { PartitionOwnership } from "../eventProcessor.js";
+/**
+ * @internal
+ */
+export declare class GreedyLoadBalancingStrategy implements LoadBalancingStrategy {
+    private readonly _partitionOwnershipExpirationIntervalInMs;
+    /**
+     * Creates an instance of GreedyLoadBalancingStrategy.
+     *
+     * @param _partitionOwnershipExpirationIntervalInMs - The length of time a partition claim is valid.
+     */
+    constructor(_partitionOwnershipExpirationIntervalInMs: number);
+    /**
+     * Implements load balancing by taking into account current ownership and
+     * the new set of partitions to add.
+     * @param ourOwnerId - The id we should assume is _our_ id when checking for ownership.
+     * @param claimedPartitionOwnershipMap - The current claimed ownerships for partitions.
+     * @param partitionIds - Partitions to assign owners to.
+     * @returns Partition ids to claim.
+     */
+    getPartitionsToClaim(ourOwnerId: string, claimedPartitionOwnershipMap: Map<string, PartitionOwnership>, partitionIds: string[]): string[];
+}
+//# sourceMappingURL=greedyStrategy.d.ts.map

package/dist/react-native/loadBalancerStrategies/greedyStrategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"greedyStrategy.d.ts","sourceRoot":"","sources":["../../../src/loadBalancerStrategies/greedyStrategy.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAExE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE/D;;GAEG;AACH,qBAAa,2BAA4B,YAAW,qBAAqB;IAM3D,OAAO,CAAC,QAAQ,CAAC,yCAAyC;IALtE;;;;OAIG;gBAC0B,yCAAyC,EAAE,MAAM;IAE9E;;;;;;;OAOG;IACI,oBAAoB,CACzB,UAAU,EAAE,MAAM,EAClB,4BAA4B,EAAE,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,EAC7D,YAAY,EAAE,MAAM,EAAE,GACrB,MAAM,EAAE;CAQZ"}

package/dist/react-native/loadBalancerStrategies/greedyStrategy.js

@@ -0,0 +1,29 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { listAvailablePartitions } from "./loadBalancingStrategy.js";
+/**
+ * @internal
+ */
+export class GreedyLoadBalancingStrategy {
+    _partitionOwnershipExpirationIntervalInMs;
+    /**
+     * Creates an instance of GreedyLoadBalancingStrategy.
+     *
+     * @param _partitionOwnershipExpirationIntervalInMs - The length of time a partition claim is valid.
+     */
+    constructor(_partitionOwnershipExpirationIntervalInMs) {
+        this._partitionOwnershipExpirationIntervalInMs = _partitionOwnershipExpirationIntervalInMs;
+    }
+    /**
+     * Implements load balancing by taking into account current ownership and
+     * the new set of partitions to add.
+     * @param ourOwnerId - The id we should assume is _our_ id when checking for ownership.
+     * @param claimedPartitionOwnershipMap - The current claimed ownerships for partitions.
+     * @param partitionIds - Partitions to assign owners to.
+     * @returns Partition ids to claim.
+     */
+    getPartitionsToClaim(ourOwnerId, claimedPartitionOwnershipMap, partitionIds) {
+        return listAvailablePartitions(ourOwnerId, claimedPartitionOwnershipMap, partitionIds, this._partitionOwnershipExpirationIntervalInMs);
+    }
+}
+//# sourceMappingURL=greedyStrategy.js.map

package/dist/react-native/loadBalancerStrategies/greedyStrategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"greedyStrategy.js","sourceRoot":"","sources":["../../../src/loadBalancerStrategies/greedyStrategy.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,kCAAkC;AAGlC,OAAO,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AAGrE;;GAEG;AACH,MAAM,OAAO,2BAA2B;IAMT;IAL7B;;;;OAIG;IACH,YAA6B,yCAAiD;QAAjD,8CAAyC,GAAzC,yCAAyC,CAAQ;IAAG,CAAC;IAElF;;;;;;;OAOG;IACI,oBAAoB,CACzB,UAAkB,EAClB,4BAA6D,EAC7D,YAAsB;QAEtB,OAAO,uBAAuB,CAC5B,UAAU,EACV,4BAA4B,EAC5B,YAAY,EACZ,IAAI,CAAC,yCAAyC,CAC/C,CAAC;IACJ,CAAC;CACF","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type { LoadBalancingStrategy } from \"./loadBalancingStrategy.js\";\nimport { listAvailablePartitions } from \"./loadBalancingStrategy.js\";\nimport type { PartitionOwnership } from \"../eventProcessor.js\";\n\n/**\n * @internal\n */\nexport class GreedyLoadBalancingStrategy implements LoadBalancingStrategy {\n  /**\n   * Creates an instance of GreedyLoadBalancingStrategy.\n   *\n   * @param _partitionOwnershipExpirationIntervalInMs - The length of time a partition claim is valid.\n   */\n  constructor(private readonly _partitionOwnershipExpirationIntervalInMs: number) {}\n\n  /**\n   * Implements load balancing by taking into account current ownership and\n   * the new set of partitions to add.\n   * @param ourOwnerId - The id we should assume is _our_ id when checking for ownership.\n   * @param claimedPartitionOwnershipMap - The current claimed ownerships for partitions.\n   * @param partitionIds - Partitions to assign owners to.\n   * @returns Partition ids to claim.\n   */\n  public getPartitionsToClaim(\n    ourOwnerId: string,\n    claimedPartitionOwnershipMap: Map<string, PartitionOwnership>,\n    partitionIds: string[],\n  ): string[] {\n    return listAvailablePartitions(\n      ourOwnerId,\n      claimedPartitionOwnershipMap,\n      partitionIds,\n      this._partitionOwnershipExpirationIntervalInMs,\n    );\n  }\n}\n"]}

package/dist/react-native/loadBalancerStrategies/loadBalancingStrategy.d.ts

@@ -0,0 +1,28 @@
+import type { PartitionOwnership } from "../eventProcessor.js";
+/**
+ * Determines which partitions to claim as part of load balancing.
+ * @internal
+ */
+export interface LoadBalancingStrategy {
+    /**
+     * Implements load balancing by taking into account current ownership and
+     * the full set of partitions in the Event Hub.
+     * @param ourOwnerId - The id we should assume is _our_ id when checking for ownership.
+     * @param claimedPartitionOwnershipMap - The current claimed ownerships for partitions.
+     * @param partitionIds - Partitions to assign owners to.
+     * @returns Partition ids to claim.
+     */
+    getPartitionsToClaim(ownerId: string, claimedPartitionOwnershipMap: Map<string, PartitionOwnership>, partitionIds: string[]): string[];
+}
+/**
+ * Identifies all of the partitions that can be claimed by the specified owner for
+ * that owner to reach a balanced state.
+ * @param OwnerId - The id we should assume is _our_ id when checking for ownership.
+ * @param claimedPartitionOwnershipMap - The current claimed ownerships for partitions.
+ * @param partitionIds - Partitions to assign owners to.
+ * @param expirationIntervalInMs - The length of time a partition claim is valid.
+ * @returns Partition ids that may be claimed.
+ * @internal
+ */
+export declare function listAvailablePartitions(ownerId: string, claimedPartitionOwnershipMap: Map<string, PartitionOwnership>, partitionIds: string[], expirationIntervalInMs: number): string[];
+//# sourceMappingURL=loadBalancingStrategy.d.ts.map

package/dist/react-native/loadBalancerStrategies/loadBalancingStrategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadBalancingStrategy.d.ts","sourceRoot":"","sources":["../../../src/loadBalancerStrategies/loadBalancingStrategy.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAG/D;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;;;;;OAOG;IACH,oBAAoB,CAClB,OAAO,EAAE,MAAM,EACf,4BAA4B,EAAE,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,EAC7D,YAAY,EAAE,MAAM,EAAE,GACrB,MAAM,EAAE,CAAC;CACb;AA2PD;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,MAAM,EACf,4BAA4B,EAAE,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,EAC7D,YAAY,EAAE,MAAM,EAAE,EACtB,sBAAsB,EAAE,MAAM,GAC7B,MAAM,EAAE,CA8FV"}

package/dist/react-native/loadBalancerStrategies/loadBalancingStrategy.js

@@ -0,0 +1,245 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { logger } from "../logger.js";
+/**
+ * This method will create a new map of partition id and PartitionOwnership containing only those partitions
+ * that are actively owned.
+ * All entries in the original map that haven't been modified for a duration of time greater than the allowed
+ * inactivity time limit are assumed to be owned by dead event processors.
+ * These will not be included in the map returned by this method.
+ *
+ * @param partitionOwnershipMap - The existing PartitionOwnerships mapped by partition.
+ * @param expirationIntervalInMs - The length of time a PartitionOwnership claim is valid.
+ */
+function getActivePartitionOwnerships(partitionOwnershipMap, expirationIntervalInMs) {
+    const activePartitionOwnershipMap = new Map();
+    partitionOwnershipMap.forEach((partitionOwnership, partitionId) => {
+        // If lastModifiedtimeInMs is missing, assume it is inactive.
+        if (typeof partitionOwnership.lastModifiedTimeInMs === "undefined" ||
+            partitionOwnership.lastModifiedTimeInMs === null) {
+            return;
+        }
+        const timeSincePartitionClaimed = Date.now() - partitionOwnership.lastModifiedTimeInMs;
+        if (timeSincePartitionClaimed < expirationIntervalInMs && partitionOwnership.ownerId) {
+            activePartitionOwnershipMap.set(partitionId, partitionOwnership);
+        }
+    });
+    return activePartitionOwnershipMap;
+}
+/**
+ * Calculates the minimum number of partitions each EventProcessor should own,
+ * and the number of EventProcessors that should have an extra partition assigned.
+ * @param ownerToOwnershipMap - The current ownerships for partitions.
+ * @param partitionIds - The full list of the Event Hub's partition ids.
+ * @internal
+ */
+function calculateBalancedLoadCounts(ownerToOwnershipMap, partitionIds) {
+    // Calculate the minimum number of partitions every EventProcessor should own when the load
+    // is evenly distributed.
+    const minPartitionsPerOwner = Math.floor(partitionIds.length / ownerToOwnershipMap.size);
+    // If the number of partitions in the Event Hub is not evenly divisible by the number of active
+    // EventProcesrrors, some EventProcessors may own 1 partition in addition to the minimum when the
+    // load is balanced.
+    // Calculate the number of EventProcessors that can own an additional partition.
+    const requiredNumberOfOwnersWithExtraPartition = partitionIds.length % ownerToOwnershipMap.size;
+    return {
+        minPartitionsPerOwner,
+        requiredNumberOfOwnersWithExtraPartition,
+    };
+}
+/**
+ * Counts the EventProcessors and tallies them by type.
+ *
+ * To be in balance we need to make sure that each EventProcessor is only consuming
+ * their fair share.
+ *
+ * When the partitions are divvied up we will sometimes end up with some EventProcessors
+ * that will have 1 more partition than others.
+ * This can happen if the number of partitions is not evenly divisible by the number of EventProcessors.
+ *
+ * So this function largely exists to support isLoadBalanced() and
+ * shouldOwnMorePartitions(), both of which depend on knowing if our current list
+ * of EventProcessors is actually in the proper state.
+ *
+ * @param minPartitionsPerOwner - The number of required partitions per EventProcessor.
+ * @param ownerToOwnershipMap - The current ownerships for partitions.
+ * @internal
+ */
+function getEventProcessorCounts(minPartitionsPerOwner, ownerToOwnershipMap) {
+    const counts = {
+        haveRequiredPartitions: 0,
+        haveAdditionalPartition: 0,
+        haveTooManyPartitions: 0,
+    };
+    for (const ownershipList of ownerToOwnershipMap.values()) {
+        const numberOfPartitions = ownershipList.length;
+        // there are basically three kinds of partition counts
+        // for a processor:
+        if (numberOfPartitions === minPartitionsPerOwner) {
+            // 1. Has _exactly_ the required number of partitions
+            counts.haveRequiredPartitions++;
+        }
+        else if (numberOfPartitions === minPartitionsPerOwner + 1) {
+            // 2. Has the required number plus one extra (correct in cases)
+            // where the # of partitions is not evenly divisible by the
+            // number of processors.
+            counts.haveAdditionalPartition++;
+        }
+        else if (numberOfPartitions > minPartitionsPerOwner + 1) {
+            // 3. has more than the possible # of partitions required
+            counts.haveTooManyPartitions++;
+        }
+    }
+    return counts;
+}
+/**
+ * Validates that we are currently in a balanced state - all EventProcessors own the
+ * minimum required number of partitions (and additional partitions, if the # of partitions
+ * is not evenly divisible by the # of EventProcessors).
+ *
+ * @param requiredNumberOfOwnersWithExtraPartition - The # of EventProcessors that process an additional partition, in addition to the required minimum.
+ * @param totalExpectedProcessors - The total # of EventProcessors we expect.
+ * @param eventProcessorCounts - EventProcessor counts, grouped by criteria.
+ * @internal
+ */
+function isLoadBalanced(requiredNumberOfOwnersWithExtraPartition, totalExpectedEventProcessors, { haveAdditionalPartition, haveRequiredPartitions }) {
+    return (haveAdditionalPartition === requiredNumberOfOwnersWithExtraPartition &&
+        haveRequiredPartitions + haveAdditionalPartition === totalExpectedEventProcessors);
+}
+/**
+ * Determines the number of new partitions to claim for this particular processor.
+ *
+ * @param minRequired - The minimum required number of partitions.
+ * @param requiredNumberOfOwnersWithExtraPartition - The current number of processors that should have an additional partition.
+ * @param numPartitionsOwnedByUs - The number of partitions we currently own.
+ * @param eventProcessorCounts - Processors, grouped by criteria.
+ * @internal
+ */
+function getNumberOfPartitionsToClaim(minRequiredPartitionCount, requiredNumberOfOwnersWithExtraPartition, numPartitionsOwnedByUs, { haveAdditionalPartition, haveTooManyPartitions }) {
+    let actualRequiredPartitionCount = minRequiredPartitionCount;
+    if (requiredNumberOfOwnersWithExtraPartition > 0 &&
+        // Eventually the `haveTooManyPartitions` will decay into `haveAdditionalPartition`
+        // EventProcessors as partitions are balanced to consumers that aren't at par.
+        // We can consider them to be `haveAdditionalPartition` EventProcessors for our purposes.
+        haveAdditionalPartition + haveTooManyPartitions < requiredNumberOfOwnersWithExtraPartition) {
+        // Overall we don't have enough EventProcessors that are taking on an additional partition
+        // so we should attempt to.
+        actualRequiredPartitionCount = minRequiredPartitionCount + 1;
+    }
+    return actualRequiredPartitionCount - numPartitionsOwnedByUs;
+}
+/**
+ * Determines which partitions can be stolen from other owners while maintaining
+ * a balanced state.
+ * @param numberOfPartitionsToClaim - The number of partitions the owner needs to claim to reach a balanced state.
+ * @param minPartitionsPerOwner - The minimum number of partitions each owner needs for the partition load to be balanced.
+ * @param requiredNumberOfOwnersWithExtraPartition - The number of owners that should have 1 extra partition.
+ * @param ourOwnerId - The id of _our_ owner.
+ * @param ownerToOwnershipMap - The current ownerships for partitions.
+ * @internal
+ */
+function findPartitionsToSteal(numberOfPartitionsToClaim, minPartitionsPerOwner, requiredNumberOfOwnersWithExtraPartition, ourOwnerId, ownerToOwnershipMap) {
+    const partitionsToSteal = [];
+    // Create a list of PartitionOwnership lists that we can steal from.
+    const listOfPartitionOwnerships = [];
+    ownerToOwnershipMap.forEach((partitionOwnerships, ownerId) => {
+        if (ownerId === ourOwnerId || partitionOwnerships.length <= minPartitionsPerOwner)
+            return;
+        listOfPartitionOwnerships.push(partitionOwnerships);
+    });
+    // Sort the list in descending order based on the length of each element.
+    listOfPartitionOwnerships.sort((a, b) => {
+        if (a.length > b.length)
+            return -1;
+        if (a.length < b.length)
+            return 1;
+        return 0;
+    });
+    // Attempt to steal partitions from EventProcessors that have the most partitions 1st,
+    // then work our way down.
+    let ownersEncounteredWithExtraPartitions = 0;
+    let currentPartitionOwnershipList = listOfPartitionOwnerships.shift();
+    while (numberOfPartitionsToClaim > 0 && currentPartitionOwnershipList) {
+        let ownersExpectedPartitionCount = minPartitionsPerOwner;
+        // Determine if the current owner should be allowed to have an extra partition.
+        if (ownersEncounteredWithExtraPartitions < requiredNumberOfOwnersWithExtraPartition) {
+            ownersExpectedPartitionCount++;
+        }
+        ownersEncounteredWithExtraPartitions++;
+        let numberAvailableToSteal = currentPartitionOwnershipList.length - ownersExpectedPartitionCount;
+        // Claim as many random partitions as possible.
+        while (Math.min(numberOfPartitionsToClaim, numberAvailableToSteal)) {
+            const indexToClaim = Math.floor(Math.random() * currentPartitionOwnershipList.length);
+            partitionsToSteal.push(currentPartitionOwnershipList.splice(indexToClaim, 1)[0].partitionId);
+            numberOfPartitionsToClaim--;
+            numberAvailableToSteal--;
+        }
+        // Move on to the next list of PartitionOwnership.
+        currentPartitionOwnershipList = listOfPartitionOwnerships.shift();
+    }
+    return partitionsToSteal;
+}
+/**
+ * Identifies all of the partitions that can be claimed by the specified owner for
+ * that owner to reach a balanced state.
+ * @param OwnerId - The id we should assume is _our_ id when checking for ownership.
+ * @param claimedPartitionOwnershipMap - The current claimed ownerships for partitions.
+ * @param partitionIds - Partitions to assign owners to.
+ * @param expirationIntervalInMs - The length of time a partition claim is valid.
+ * @returns Partition ids that may be claimed.
+ * @internal
+ */
+export function listAvailablePartitions(ownerId, claimedPartitionOwnershipMap, partitionIds, expirationIntervalInMs) {
+    if (!partitionIds.length) {
+        return [];
+    }
+    // Collect only the PartitionOwnership that have been updated within the expiration interval.
+    // Any PartitionOwnership that has been updated outside the expiration interval can be claimed.
+    const activePartitionOwnershipMap = getActivePartitionOwnerships(claimedPartitionOwnershipMap, expirationIntervalInMs);
+    logger.verbose(`[${ownerId}] Number of active ownership records: ${activePartitionOwnershipMap.size}.`);
+    if (activePartitionOwnershipMap.size === 0) {
+        // All partitions in this Event Hub are available to claim.
+        return partitionIds;
+    }
+    // Map ownerIds to the partitions they own so that we can determine how many each owner has.
+    const ownerToOwnershipMap = new Map();
+    for (const activeOwnership of activePartitionOwnershipMap.values()) {
+        const partitionOwnershipList = ownerToOwnershipMap.get(activeOwnership.ownerId) || [];
+        partitionOwnershipList.push(activeOwnership);
+        ownerToOwnershipMap.set(activeOwnership.ownerId, partitionOwnershipList);
+    }
+    // Add the current EventProcessor to the map of owners to ownerships if it doesn't exist.
+    if (!ownerToOwnershipMap.has(ownerId)) {
+        ownerToOwnershipMap.set(ownerId, []);
+    }
+    logger.info(`[${ownerId}] Number of active event processors: ${ownerToOwnershipMap.size}.`);
+    const { minPartitionsPerOwner, requiredNumberOfOwnersWithExtraPartition } = calculateBalancedLoadCounts(ownerToOwnershipMap, partitionIds);
+    logger.verbose(`[${ownerId}] Expected minimum number of partitions per event processor: ${minPartitionsPerOwner},` +
+        `expected number of event processors with additional partition: ${requiredNumberOfOwnersWithExtraPartition}.`);
+    // Get some stats representing the current state the world with regards to how balanced the
+    // partitions are across EventProcessors.
+    const eventProcessorCounts = getEventProcessorCounts(minPartitionsPerOwner, ownerToOwnershipMap);
+    if (isLoadBalanced(requiredNumberOfOwnersWithExtraPartition, ownerToOwnershipMap.size, eventProcessorCounts)) {
+        // When the partitions are evenly distributed, no change required.
+        return [];
+    }
+    let numberOfPartitionsToClaim = getNumberOfPartitionsToClaim(minPartitionsPerOwner, requiredNumberOfOwnersWithExtraPartition, ownerToOwnershipMap.get(ownerId).length, eventProcessorCounts);
+    if (numberOfPartitionsToClaim <= 0) {
+        return [];
+    }
+    const partitionsToClaim = [];
+    const unclaimedPartitionIds = partitionIds.filter((id) => !activePartitionOwnershipMap.has(id));
+    // Prioritize getting unclaimed partitions first.
+    while (Math.min(numberOfPartitionsToClaim, unclaimedPartitionIds.length)) {
+        const indexToClaim = Math.floor(Math.random() * unclaimedPartitionIds.length);
+        partitionsToClaim.push(unclaimedPartitionIds.splice(indexToClaim, 1)[0]);
+        numberOfPartitionsToClaim--;
+    }
+    if (numberOfPartitionsToClaim === 0) {
+        return partitionsToClaim;
+    }
+    // Find partitions that can be stolen from other EventProcessors.
+    const partitionsToSteal = findPartitionsToSteal(numberOfPartitionsToClaim, minPartitionsPerOwner, requiredNumberOfOwnersWithExtraPartition, ownerId, ownerToOwnershipMap);
+    return partitionsToClaim.concat(partitionsToSteal);
+}
+//# sourceMappingURL=loadBalancingStrategy.js.map