@azure/event-hubs 5.13.0-alpha.20240729.1 → 5.13.0-alpha.20240731.3

package/dist/browser/eventhubConnectionConfig.d.ts

@@ -0,0 +1,96 @@
+import { ConnectionConfig } from "@azure/core-amqp";
+/**
+ * Describes the connection config object that is created after parsing an EventHub connection
+ * string. It also provides some convenience methods for getting the address and audience for
+ * different entities.
+ * @internal
+ */
+export interface EventHubConnectionConfig extends ConnectionConfig {
+    /**
+     * The name/path of the entity (event hub name) to which the
+     * connection needs to happen.
+     */
+    entityPath: string;
+    /**
+     * Provides the EventHub Sender address in one of the following forms based on the input:
+     * - `"<hubName>"`
+     * - `"<hubName>/Partitions/<partitionId>"`
+     *
+     * @param partitionId - The partitionId in the EventHub to which messages will be sent.
+     */
+    getSenderAddress(partitionId?: string | number): string;
+    /**
+     * Provides the EventHub Sender audience in one of the following forms based on the input:
+     * - `"sb://<yournamespace>.servicebus.windows.net/<hubName>"`
+     * - `"sb://<yournamespace>.servicebus.windows.net/<hubName>/Partitions/<partitionId>"`
+     *
+     * @param partitionId - The partitionId in the EventHub to which messages will be sent.
+     */
+    getSenderAudience(partitionId?: string | number): string;
+    /**
+     * Provides the EventHub Receiver address:
+     * - `"<hub-name>/ConsumerGroups/<consumer-group-name>/Partitions/<partition-id>"`
+     *
+     * @param partitionId - The partitionId in the EventHub from which messages will be received.
+     * @param consumergroup - The consumergroup in the EventHub from which the messages will
+     * be received. Default: `$default`.
+     */
+    getReceiverAddress(partitionId: string | number, consumergroup?: string): string;
+    /**
+     * Provides the EventHub Receiver audience.
+     * - `"sb://<your-namespace>.servicebus.windows.net/<hub-name>/ConsumerGroups/<consumer-group-name>/Partitions/<partition-id>"`
+     *
+     * @param partitionId - The partitionId in the EventHub from which messages will be received.
+     * @param consumergroup - The consumergroup in the EventHub from which the messages will
+     * be received. Default: `$default`.
+     */
+    getReceiverAudience(partitionId: string | number, consumergroup?: string): string;
+    /**
+     * Provides the EventHub Management address.
+     * - `"<hub-name>/$management"`
+     */
+    getManagementAddress(): string;
+    /**
+     * Provides the EventHub Management audience.
+     * - `"sb://<your-namespace>.servicebus.windows.net/<hub-name>/$management"`
+     */
+    getManagementAudience(): string;
+}
+/**
+ * Describes the connection config object that is created after parsing an EventHub connection
+ * string. It also provides some convenience methods for getting the address and audience for
+ * different entities.
+ * @internal
+ */
+export declare const EventHubConnectionConfig: {
+    /**
+     * Creates the connection config.
+     * @param connectionString - The connection string for a given service like
+     * EventHub/ServiceBus.
+     * @param path - The name/path of the entity (hub name) to which the
+     * connection needs to happen. This will override the EntityPath in the connectionString
+     * if present.
+     * @returns EventHubConnectionConfig
+     */
+    create(connectionString: string, path?: string): EventHubConnectionConfig;
+    /**
+     * Creates an EventHubConnectionConfig from the provided base ConnectionConfig.
+     * @param config - The base connection config from which the EventHubConnectionConfig needs to be
+     * created.
+     * @returns EventHubConnectionConfig
+     */
+    createFromConnectionConfig(config: ConnectionConfig): EventHubConnectionConfig;
+    /**
+     * Updates the provided EventHubConnectionConfig to use the custom endpoint address.
+     * @param config - An existing connection configuration to be updated.
+     * @param customEndpointAddress - The custom endpoint address to use.
+     */
+    setCustomEndpointAddress(config: EventHubConnectionConfig, customEndpointAddress: string): void;
+    /**
+     * Validates the properties of connection config.
+     * @param config - The connection config to be validated.
+     * @returns void
+     */
+    validate(config: EventHubConnectionConfig): void;
+};
+//# sourceMappingURL=eventhubConnectionConfig.d.ts.map

package/dist/browser/eventhubConnectionConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eventhubConnectionConfig.d.ts","sourceRoot":"","sources":["../../src/eventhubConnectionConfig.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAGpD;;;;;GAKG;AACH,MAAM,WAAW,wBAAyB,SAAQ,gBAAgB;IAChE;;;OAGG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB;;;;;;OAMG;IACH,gBAAgB,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;IACxD;;;;;;OAMG;IACH,iBAAiB,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;IACzD;;;;;;;OAOG;IACH,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACjF;;;;;;;OAOG;IACH,mBAAmB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAClF;;;OAGG;IACH,oBAAoB,IAAI,MAAM,CAAC;IAC/B;;;OAGG;IACH,qBAAqB,IAAI,MAAM,CAAC;CACjC;AAED;;;;;GAKG;AAEH,eAAO,MAAM,wBAAwB;IACnC;;;;;;;;OAQG;6BACsB,MAAM,SAAS,MAAM,GAAG,wBAAwB;IAWzE;;;;;OAKG;uCACgC,gBAAgB,GAAG,wBAAwB;IA+C9E;;;;OAIG;qCAC8B,wBAAwB,yBAAyB,MAAM,GAAG,IAAI;IAW/F;;;;OAIG;qBACc,wBAAwB,GAAG,IAAI;CAGjD,CAAC"}

package/{dist-esm/src → dist/browser}/eventhubConnectionConfig.js

@@ -2,7 +2,7 @@
 // Licensed under the MIT license.
 /* eslint-disable eqeqeq */
 import { ConnectionConfig } from "@azure/core-amqp";
-import { parseEndpoint } from "./util/parseEndpoint";
+import { parseEndpoint } from "./util/parseEndpoint.js";
 /**
  * Describes the connection config object that is created after parsing an EventHub connection
  * string. It also provides some convenience methods for getting the address and audience for

package/dist/browser/eventhubConnectionConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"eventhubConnectionConfig.js","sourceRoot":"","sources":["../../src/eventhubConnectionConfig.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\n/* eslint-disable eqeqeq */\n\nimport { ConnectionConfig } from \"@azure/core-amqp\";\nimport { parseEndpoint } from \"./util/parseEndpoint.js\";\n\n/**\n * Describes the connection config object that is created after parsing an EventHub connection\n * string. It also provides some convenience methods for getting the address and audience for\n * different entities.\n * @internal\n */\nexport interface EventHubConnectionConfig extends ConnectionConfig {\n  /**\n   * The name/path of the entity (event hub name) to which the\n   * connection needs to happen.\n   */\n  entityPath: string;\n  /**\n   * Provides the EventHub Sender address in one of the following forms based on the input:\n   * - `\"<hubName>\"`\n   * - `\"<hubName>/Partitions/<partitionId>\"`\n   *\n   * @param partitionId - The partitionId in the EventHub to which messages will be sent.\n   */\n  getSenderAddress(partitionId?: string | number): string;\n  /**\n   * Provides the EventHub Sender audience in one of the following forms based on the input:\n   * - `\"sb://<yournamespace>.servicebus.windows.net/<hubName>\"`\n   * - `\"sb://<yournamespace>.servicebus.windows.net/<hubName>/Partitions/<partitionId>\"`\n   *\n   * @param partitionId - The partitionId in the EventHub to which messages will be sent.\n   */\n  getSenderAudience(partitionId?: string | number): string;\n  /**\n   * Provides the EventHub Receiver address:\n   * - `\"<hub-name>/ConsumerGroups/<consumer-group-name>/Partitions/<partition-id>\"`\n   *\n   * @param partitionId - The partitionId in the EventHub from which messages will be received.\n   * @param consumergroup - The consumergroup in the EventHub from which the messages will\n   * be received. Default: `$default`.\n   */\n  getReceiverAddress(partitionId: string | number, consumergroup?: string): string;\n  /**\n   * Provides the EventHub Receiver audience.\n   * - `\"sb://<your-namespace>.servicebus.windows.net/<hub-name>/ConsumerGroups/<consumer-group-name>/Partitions/<partition-id>\"`\n   *\n   * @param partitionId - The partitionId in the EventHub from which messages will be received.\n   * @param consumergroup - The consumergroup in the EventHub from which the messages will\n   * be received. Default: `$default`.\n   */\n  getReceiverAudience(partitionId: string | number, consumergroup?: string): string;\n  /**\n   * Provides the EventHub Management address.\n   * - `\"<hub-name>/$management\"`\n   */\n  getManagementAddress(): string;\n  /**\n   * Provides the EventHub Management audience.\n   * - `\"sb://<your-namespace>.servicebus.windows.net/<hub-name>/$management\"`\n   */\n  getManagementAudience(): string;\n}\n\n/**\n * Describes the connection config object that is created after parsing an EventHub connection\n * string. It also provides some convenience methods for getting the address and audience for\n * different entities.\n * @internal\n */\n// eslint-disable-next-line @typescript-eslint/no-redeclare -- renaming constant would be a breaking change.\nexport const EventHubConnectionConfig = {\n  /**\n   * Creates the connection config.\n   * @param connectionString - The connection string for a given service like\n   * EventHub/ServiceBus.\n   * @param path - The name/path of the entity (hub name) to which the\n   * connection needs to happen. This will override the EntityPath in the connectionString\n   * if present.\n   * @returns EventHubConnectionConfig\n   */\n  create(connectionString: string, path?: string): EventHubConnectionConfig {\n    const config = ConnectionConfig.create(connectionString, path);\n    if (!config.entityPath) {\n      throw new TypeError(\n        `Either provide \"path\" or the \"connectionString\": \"${connectionString}\", ` +\n          `must contain EntityPath=\"<path-to-the-entity>\".`,\n      );\n    }\n    return EventHubConnectionConfig.createFromConnectionConfig(config);\n  },\n\n  /**\n   * Creates an EventHubConnectionConfig from the provided base ConnectionConfig.\n   * @param config - The base connection config from which the EventHubConnectionConfig needs to be\n   * created.\n   * @returns EventHubConnectionConfig\n   */\n  createFromConnectionConfig(config: ConnectionConfig): EventHubConnectionConfig {\n    ConnectionConfig.validate(config, { isEntityPathRequired: true });\n\n    (config as EventHubConnectionConfig).getManagementAudience = () => {\n      return `${config.endpoint}${config.entityPath}/$management`;\n    };\n    (config as EventHubConnectionConfig).getManagementAddress = () => {\n      return `${config.entityPath}/$management`;\n    };\n\n    (config as EventHubConnectionConfig).getSenderAudience = (partitionId?: string | number) => {\n      if (partitionId != undefined) {\n        return `${config.endpoint}${config.entityPath}/Partitions/${partitionId}`;\n      } else {\n        return `${config.endpoint}${config.entityPath}`;\n      }\n    };\n\n    (config as EventHubConnectionConfig).getSenderAddress = (partitionId?: string | number) => {\n      if (partitionId != undefined) {\n        return `${config.entityPath}/Partitions/${partitionId}`;\n      } else {\n        return `${config.entityPath}`;\n      }\n    };\n\n    (config as EventHubConnectionConfig).getReceiverAudience = (\n      partitionId: string | number,\n      consumergroup?: string,\n    ) => {\n      if (!consumergroup) consumergroup = \"$default\";\n      return (\n        `${config.endpoint}${config.entityPath}/ConsumerGroups/${consumergroup}/` +\n        `Partitions/${partitionId}`\n      );\n    };\n\n    (config as EventHubConnectionConfig).getReceiverAddress = (\n      partitionId: string | number,\n      consumergroup?: string,\n    ) => {\n      if (!consumergroup) consumergroup = \"$default\";\n      return `${config.entityPath}/ConsumerGroups/${consumergroup}/Partitions/${partitionId}`;\n    };\n    return config as EventHubConnectionConfig;\n  },\n\n  /**\n   * Updates the provided EventHubConnectionConfig to use the custom endpoint address.\n   * @param config - An existing connection configuration to be updated.\n   * @param customEndpointAddress - The custom endpoint address to use.\n   */\n  setCustomEndpointAddress(config: EventHubConnectionConfig, customEndpointAddress: string): void {\n    // The amqpHostname should match the host prior to using the custom endpoint.\n    config.amqpHostname = config.host;\n    const { hostname, port } = parseEndpoint(customEndpointAddress);\n    // Since we specify the port separately, set host to the customEndpointAddress hostname.\n    config.host = hostname;\n    if (port) {\n      config.port = parseInt(port, 10);\n    }\n  },\n\n  /**\n   * Validates the properties of connection config.\n   * @param config - The connection config to be validated.\n   * @returns void\n   */\n  validate(config: EventHubConnectionConfig): void {\n    return ConnectionConfig.validate(config, { isEntityPathRequired: true });\n  },\n};\n"]}

package/dist/browser/impl/awaitableQueue.d.ts

@@ -0,0 +1,25 @@
+import { AbortOptions } from "@azure/core-util";
+/**
+ * `AwaitableQueue` stores items in the order that they are received.
+ *
+ * This differs from ordinary Queues in that `shift` returns a Promise for a value.
+ * This allows a consumer of the queue to request an item that the queue does not yet have.
+ *
+ * @internal
+ */
+export declare class AwaitableQueue<T> {
+    private readonly _items;
+    private readonly _resolvers;
+    constructor();
+    size(): number;
+    /**
+     * Returns a Promise that will resolve with the next item in the queue.
+     */
+    shift(options?: AbortOptions): Promise<T>;
+    /**
+     * Appends new item to the queue.
+     */
+    push(item: T): void;
+    private _resolveNextItem;
+}
+//# sourceMappingURL=awaitableQueue.d.ts.map

package/dist/browser/impl/awaitableQueue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"awaitableQueue.d.ts","sourceRoot":"","sources":["../../../src/impl/awaitableQueue.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,YAAY,EAA0B,MAAM,kBAAkB,CAAC;AAExE;;;;;;;GAOG;AACH,qBAAa,cAAc,CAAC,CAAC;IAC3B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAM;IAE7B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAiC;;IAMrD,IAAI,IAAI,MAAM;IAIrB;;OAEG;IACI,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,CAAC,CAAC;IAYhD;;OAEG;IACI,IAAI,CAAC,IAAI,EAAE,CAAC,GAAG,IAAI;IAM1B,OAAO,CAAC,gBAAgB;CASzB"}

package/dist/browser/impl/partitionAssigner.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @internal
+ * Assigns a partition based on the partition ids it knows about and an optional partition id or partition key.
+ */
+export declare class PartitionAssigner {
+    private _partitions;
+    private _lastRoundRobinPartitionIndex;
+    /**
+     * Set the partition ids that can be used when assigning a partition.
+     * @param partitionIds - All valid partition ids.
+     */
+    setPartitionIds(partitionIds: string[]): void;
+    /**
+     * Returns a partitionId from the list of partition ids set via `setPartitionIds`.
+     *
+     * If a partitionId is specified, then that will be returned directly.
+     * If a partitionKey is specified, then a partitionId will be calculated based on the partitionKey.
+     * Specifying both partitionId and partitionKey results in an error.
+     *
+     * If neither partitionId nor partitionKey are specified, then a partitionId will be selected
+     * based on a round-robin approach.
+     */
+    assignPartition({ partitionId, partitionKey, }: {
+        partitionId?: string;
+        partitionKey?: string;
+    }): string;
+    private _assignRoundRobinPartition;
+}
+//# sourceMappingURL=partitionAssigner.d.ts.map

package/dist/browser/impl/partitionAssigner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partitionAssigner.d.ts","sourceRoot":"","sources":["../../../src/impl/partitionAssigner.ts"],"names":[],"mappings":"AAMA;;;GAGG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,WAAW,CAAgB;IAEnC,OAAO,CAAC,6BAA6B,CAAc;IAEnD;;;OAGG;IACI,eAAe,CAAC,YAAY,EAAE,MAAM,EAAE,GAAG,IAAI;IAIpD;;;;;;;;;OASG;IACH,eAAe,CAAC,EACd,WAAW,EACX,YAAY,GACb,EAAE;QACD,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,YAAY,CAAC,EAAE,MAAM,CAAC;KACvB,GAAG,MAAM;IAsBV,OAAO,CAAC,0BAA0B;CAUnC"}

package/{dist-esm/src → dist/browser}/impl/partitionAssigner.js

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
 import { isDefined } from "@azure/core-util";
-import { mapPartitionKeyToId } from "./partitionKeyToIdMapper";
+import { mapPartitionKeyToId } from "./partitionKeyToIdMapper.js";
 /**
  * @internal
  * Assigns a partition based on the partition ids it knows about and an optional partition id or partition key.

package/dist/browser/impl/partitionAssigner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"partitionAssigner.js","sourceRoot":"","sources":["../../../src/impl/partitionAssigner.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,kCAAkC;AAElC,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAElE;;;GAGG;AACH,MAAM,OAAO,iBAAiB;IAA9B;QACU,gBAAW,GAAa,EAAE,CAAC;QAE3B,kCAA6B,GAAW,CAAC,CAAC,CAAC;IA0DrD,CAAC;IAxDC;;;OAGG;IACI,eAAe,CAAC,YAAsB;QAC3C,IAAI,CAAC,WAAW,GAAG,YAAY,CAAC;IAClC,CAAC;IAED;;;;;;;;;OASG;IACH,eAAe,CAAC,EACd,WAAW,EACX,YAAY,GAIb;QACC,IAAI,SAAS,CAAC,WAAW,CAAC,IAAI,SAAS,CAAC,YAAY,CAAC,EAAE,CAAC;YACtD,MAAM,IAAI,KAAK,CACb,oBAAoB,WAAW,uBAAuB,YAAY,6BAA6B,CAChG,CAAC;QACJ,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,CAAC;YAC7B,MAAM,IAAI,KAAK,CAAC,6DAA6D,CAAC,CAAC;QACjF,CAAC;QAED,IAAI,SAAS,CAAC,WAAW,CAAC,IAAI,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC;YACrE,OAAO,WAAW,CAAC;QACrB,CAAC;QAED,IAAI,SAAS,CAAC,YAAY,CAAC,EAAE,CAAC;YAC5B,OAAO,mBAAmB,CAAC,YAAY,EAAE,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,QAAQ,EAAE,CAAC;QAC/E,CAAC;QAED,OAAO,IAAI,CAAC,0BAA0B,EAAE,CAAC;IAC3C,CAAC;IAEO,0BAA0B;QAChC,MAAM,iBAAiB,GAAG,IAAI,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC;QACtD,MAAM,sBAAsB,GAAG,IAAI,CAAC,6BAA6B,GAAG,CAAC,CAAC;QAEtE,MAAM,kBAAkB,GACtB,sBAAsB,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,sBAAsB,CAAC;QAE1E,IAAI,CAAC,6BAA6B,GAAG,kBAAkB,CAAC;QACxD,OAAO,IAAI,CAAC,WAAW,CAAC,kBAAkB,CAAC,CAAC;IAC9C,CAAC;CACF","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT license.\n\nimport { isDefined } from \"@azure/core-util\";\nimport { mapPartitionKeyToId } from \"./partitionKeyToIdMapper.js\";\n\n/**\n * @internal\n * Assigns a partition based on the partition ids it knows about and an optional partition id or partition key.\n */\nexport class PartitionAssigner {\n  private _partitions: string[] = [];\n\n  private _lastRoundRobinPartitionIndex: number = -1;\n\n  /**\n   * Set the partition ids that can be used when assigning a partition.\n   * @param partitionIds - All valid partition ids.\n   */\n  public setPartitionIds(partitionIds: string[]): void {\n    this._partitions = partitionIds;\n  }\n\n  /**\n   * Returns a partitionId from the list of partition ids set via `setPartitionIds`.\n   *\n   * If a partitionId is specified, then that will be returned directly.\n   * If a partitionKey is specified, then a partitionId will be calculated based on the partitionKey.\n   * Specifying both partitionId and partitionKey results in an error.\n   *\n   * If neither partitionId nor partitionKey are specified, then a partitionId will be selected\n   * based on a round-robin approach.\n   */\n  assignPartition({\n    partitionId,\n    partitionKey,\n  }: {\n    partitionId?: string;\n    partitionKey?: string;\n  }): string {\n    if (isDefined(partitionId) && isDefined(partitionKey)) {\n      throw new Error(\n        `The partitionId (${partitionId}) and partitionKey (${partitionKey}) cannot both be specified.`,\n      );\n    }\n\n    if (!this._partitions.length) {\n      throw new Error(`Unable to determine partitionIds, can't assign partitionId.`);\n    }\n\n    if (isDefined(partitionId) && this._partitions.includes(partitionId)) {\n      return partitionId;\n    }\n\n    if (isDefined(partitionKey)) {\n      return mapPartitionKeyToId(partitionKey, this._partitions.length).toString();\n    }\n\n    return this._assignRoundRobinPartition();\n  }\n\n  private _assignRoundRobinPartition(): string {\n    const maxPartitionIndex = this._partitions.length - 1;\n    const proposedPartitionIndex = this._lastRoundRobinPartitionIndex + 1;\n\n    const nextPartitionIndex =\n      proposedPartitionIndex > maxPartitionIndex ? 0 : proposedPartitionIndex;\n\n    this._lastRoundRobinPartitionIndex = nextPartitionIndex;\n    return this._partitions[nextPartitionIndex];\n  }\n}\n"]}

package/dist/browser/impl/partitionGate.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Used by EventHubConsumerClient to prevent accidentally spinning up multiple
+ * subscriptions against the same set of partitions.
+ *
+ * This is needed now that EventHubConsumerClient only uses a single CheckpointStore
+ * instance - otherwise users will see unpredictable results as their event processor
+ * continually steals/overwrites checkpointing and ownership with itself.
+ *
+ * @internal
+ */
+export declare class PartitionGate {
+    private _partitions;
+    /**
+     * Adds a partition, throwing an Error if there is a conflict with partitions (including "all")
+     * that are already added.
+     *
+     * @param partitionId - A partition ID or the constant "all"
+     */
+    add(partitionId: string | "all"): void;
+    /**
+     * Removes a partition
+     *
+     * @param partitionId - A partition ID or the constant "all"
+     */
+    remove(partitionId: string | "all"): void;
+}
+//# sourceMappingURL=partitionGate.d.ts.map

package/dist/browser/impl/partitionGate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partitionGate.d.ts","sourceRoot":"","sources":["../../../src/impl/partitionGate.ts"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,WAAW,CAAqB;IAExC;;;;;OAKG;IACH,GAAG,CAAC,WAAW,EAAE,MAAM,GAAG,KAAK,GAAG,IAAI;IAYtC;;;;OAIG;IACH,MAAM,CAAC,WAAW,EAAE,MAAM,GAAG,KAAK,GAAG,IAAI;CAG1C"}

package/dist/browser/impl/partitionKeyToIdMapper.d.ts

@@ -0,0 +1,6 @@
+export declare function mapPartitionKeyToId(partitionKey: string, partitionCount: number): number;
+/**
+ * @internal
+ */
+export declare function hashPartitionKey(partitionKey: string): number;
+//# sourceMappingURL=partitionKeyToIdMapper.d.ts.map

package/dist/browser/impl/partitionKeyToIdMapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partitionKeyToIdMapper.d.ts","sourceRoot":"","sources":["../../../src/impl/partitionKeyToIdMapper.ts"],"names":[],"mappings":"AAKA,wBAAgB,mBAAmB,CAAC,YAAY,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,MAAM,CAGxF;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAG7D"}

package/dist/browser/inMemoryCheckpointStore.d.ts

@@ -0,0 +1,44 @@
+import { CheckpointStore, PartitionOwnership } from "./eventProcessor.js";
+import { Checkpoint } from "./partitionProcessor.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 declare class InMemoryCheckpointStore implements CheckpointStore {
+    private _partitionOwnershipMap;
+    private _committedCheckpoints;
+    /**
+     * 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..
+     */
+    listOwnership(_fullyQualifiedNamespace: string, _eventHubName: string, _consumerGroup: string): Promise<PartitionOwnership[]>;
+    /**
+     * 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.
+     */
+    claimOwnership(partitionOwnership: PartitionOwnership[]): Promise<PartitionOwnership[]>;
+    /**
+     * Updates the checkpoint in the data store for a partition.
+     *
+     * @param checkpoint - The checkpoint.
+     */
+    updateCheckpoint(checkpoint: Checkpoint): Promise<void>;
+    listCheckpoints(fullyQualifiedNamespace: string, eventHubName: string, consumerGroup: string): Promise<Checkpoint[]>;
+}
+//# sourceMappingURL=inMemoryCheckpointStore.d.ts.map

package/dist/browser/inMemoryCheckpointStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inMemoryCheckpointStore.d.ts","sourceRoot":"","sources":["../../src/inMemoryCheckpointStore.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAC1E,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAIrD;;;;;;;;;;GAUG;AACH,qBAAa,uBAAwB,YAAW,eAAe;IAC7D,OAAO,CAAC,sBAAsB,CAA8C;IAC5E,OAAO,CAAC,qBAAqB,CAAmD;IAEhF;;;;;;;;;OASG;IACG,aAAa,CACjB,wBAAwB,EAAE,MAAM,EAChC,aAAa,EAAE,MAAM,EACrB,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,kBAAkB,EAAE,CAAC;IAUhC;;;;;;OAMG;IACG,cAAc,CAAC,kBAAkB,EAAE,kBAAkB,EAAE,GAAG,OAAO,CAAC,kBAAkB,EAAE,CAAC;IAuB7F;;;;OAIG;IACG,gBAAgB,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IA2BvD,eAAe,CACnB,uBAAuB,EAAE,MAAM,EAC/B,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,UAAU,EAAE,CAAC;CAiBzB"}

package/{dist-esm/src → dist/browser}/inMemoryCheckpointStore.js

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
-import { throwTypeErrorIfParameterMissing } from "./util/error";
-import { getRandomName } from "./util/utils";
+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

package/dist/browser/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 { CheckpointStore, PartitionOwnership } from \"./eventProcessor.js\";\nimport { 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/browser/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/browser/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAKA,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-esm/src → dist/browser}/index.js

@@ -1,12 +1,12 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
-export { EventHubConsumerClient } from "./eventHubConsumerClient";
-export { EventHubProducerClient } from "./eventHubProducerClient";
-export { EventHubBufferedProducerClient, } from "./eventHubBufferedProducerClient";
-export { latestEventPosition, earliestEventPosition } from "./eventPosition";
-export { CloseReason } from "./models/public";
+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";
-export { parseEventHubConnectionString, } from "./util/connectionStringUtils";
-export * from "./eventDataAdapter";
+export { logger } from "./logger.js";
+export { parseEventHubConnectionString, } from "./util/connectionStringUtils.js";
+export * from "./eventDataAdapter.js";
 //# sourceMappingURL=index.js.map

package/dist/browser/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,kCAAkC;AAkBlC,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\n/// <reference lib=\"esnext.asynciterable\" />\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/browser/loadBalancerStrategies/balancedStrategy.d.ts

@@ -0,0 +1,30 @@
+import { LoadBalancingStrategy } from "./loadBalancingStrategy.js";
+import { 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/browser/loadBalancerStrategies/balancedStrategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"balancedStrategy.d.ts","sourceRoot":"","sources":["../../../src/loadBalancerStrategies/balancedStrategy.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,qBAAqB,EAA2B,MAAM,4BAA4B,CAAC;AAC5F,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE1D;;;;;;;;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-esm/src → dist/browser}/loadBalancerStrategies/balancedStrategy.js

@@ -1,6 +1,6 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
-import { listAvailablePartitions } from "./loadBalancingStrategy";
+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'.

package/dist/browser/loadBalancerStrategies/balancedStrategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"balancedStrategy.js","sourceRoot":"","sources":["../../../src/loadBalancerStrategies/balancedStrategy.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,kCAAkC;AAElC,OAAO,EAAyB,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AAG5F;;;;;;;;GAQG;AACH,MAAM,OAAO,6BAA6B;IACxC;;;;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 { LoadBalancingStrategy, listAvailablePartitions } from \"./loadBalancingStrategy.js\";\nimport { 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/browser/loadBalancerStrategies/greedyStrategy.d.ts

@@ -0,0 +1,24 @@
+import { LoadBalancingStrategy } from "./loadBalancingStrategy.js";
+import { 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/browser/loadBalancerStrategies/greedyStrategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"greedyStrategy.d.ts","sourceRoot":"","sources":["../../../src/loadBalancerStrategies/greedyStrategy.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,qBAAqB,EAA2B,MAAM,4BAA4B,CAAC;AAC5F,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE1D;;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-esm/src → dist/browser}/loadBalancerStrategies/greedyStrategy.js

@@ -1,6 +1,6 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
-import { listAvailablePartitions } from "./loadBalancingStrategy";
+import { listAvailablePartitions } from "./loadBalancingStrategy.js";
 /**
  * @internal
  */

package/dist/browser/loadBalancerStrategies/greedyStrategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"greedyStrategy.js","sourceRoot":"","sources":["../../../src/loadBalancerStrategies/greedyStrategy.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,kCAAkC;AAElC,OAAO,EAAyB,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AAG5F;;GAEG;AACH,MAAM,OAAO,2BAA2B;IACtC;;;;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 { LoadBalancingStrategy, listAvailablePartitions } from \"./loadBalancingStrategy.js\";\nimport { 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/browser/loadBalancerStrategies/loadBalancingStrategy.d.ts

@@ -0,0 +1,28 @@
+import { 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/browser/loadBalancerStrategies/loadBalancingStrategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadBalancingStrategy.d.ts","sourceRoot":"","sources":["../../../src/loadBalancerStrategies/loadBalancingStrategy.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAG1D;;;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-esm/src → dist/browser}/loadBalancerStrategies/loadBalancingStrategy.js

@@ -1,6 +1,6 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
-import { logger } from "../logger";
+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.

package/dist/browser/loadBalancerStrategies/loadBalancingStrategy.js.map

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