@metamask-previews/controller-utils 11.4.5-preview-b1518d1 → 11.4.5-preview-f3d5e317

package/CHANGELOG.md

@@ -9,8 +9,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
-- Add `createServicePolicy` function to assist with reducing boilerplate for service classes ([#5154](https://github.com/MetaMask/core/pull/5154), [#5143](https://github.com/MetaMask/core/pull/5143), [#5149](https://github.com/MetaMask/core/pull/5149))
-  - Also add `DEFAULT_CIRCUIT_BREAK_DURATION`, `DEFAULT_DEGRADED_THRESHOLD`, `DEFAULT_MAX_CONSECUTIVE_FAILURES`, and `DEFAULT_MAX_RETRIES` constants and `IServicePolicy` type
+- Add utility function for reducing boilerplate for service classes ([#5154](https://github.com/MetaMask/core/pull/5154), [#5143](https://github.com/MetaMask/core/pull/5143), [#5149](https://github.com/MetaMask/core/pull/5149), [#5188](https://github.com/MetaMask/core/pull/5188), [#5192](https://github.com/MetaMask/core/pull/5192))
+  - Add function `createServicePolicy`
+  - Add constants `DEFAULT_CIRCUIT_BREAK_DURATION`, `DEFAULT_DEGRADED_THRESHOLD`, `DEFAULT_MAX_CONSECUTIVE_FAILURES`, and `DEFAULT_MAX_RETRIES`
+  - Add types `ServicePolicy` and `CreateServicePolicyOptions`
+  - Re-export `BrokenCircuitError`, `CircuitState`, `handleAll`, and `handleWhen` from `cockatiel`
 
 ## [11.4.5]
 

package/dist/create-service-policy.cjs

@@ -1,7 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createServicePolicy = exports.DEFAULT_DEGRADED_THRESHOLD = exports.DEFAULT_CIRCUIT_BREAK_DURATION = exports.DEFAULT_MAX_CONSECUTIVE_FAILURES = exports.DEFAULT_MAX_RETRIES = void 0;
+exports.createServicePolicy = exports.DEFAULT_DEGRADED_THRESHOLD = exports.DEFAULT_CIRCUIT_BREAK_DURATION = exports.DEFAULT_MAX_CONSECUTIVE_FAILURES = exports.DEFAULT_MAX_RETRIES = exports.handleWhen = exports.handleAll = exports.BrokenCircuitError = exports.CircuitState = void 0;
 const cockatiel_1 = require("cockatiel");
+Object.defineProperty(exports, "BrokenCircuitError", { enumerable: true, get: function () { return cockatiel_1.BrokenCircuitError; } });
+Object.defineProperty(exports, "CircuitState", { enumerable: true, get: function () { return cockatiel_1.CircuitState; } });
+Object.defineProperty(exports, "handleAll", { enumerable: true, get: function () { return cockatiel_1.handleAll; } });
+Object.defineProperty(exports, "handleWhen", { enumerable: true, get: function () { return cockatiel_1.handleWhen; } });
 /**
  * The maximum number of times that a failing service should be re-run before
  * giving up.
@@ -9,7 +13,9 @@ const cockatiel_1 = require("cockatiel");
 exports.DEFAULT_MAX_RETRIES = 3;
 /**
  * The maximum number of times that the service is allowed to fail before
- * pausing further retries.
+ * pausing further retries. This is set to a value such that if given a
+ * service that continually fails, the policy needs to be executed 3 times
+ * before further retries are paused.
  */
 exports.DEFAULT_MAX_CONSECUTIVE_FAILURES = (1 + exports.DEFAULT_MAX_RETRIES) * 3;
 /**
@@ -52,14 +58,6 @@ exports.DEFAULT_DEGRADED_THRESHOLD = 5000;
  * @param options.degradedThreshold - The length of time (in milliseconds) that
  * governs when the service is regarded as degraded (affecting when `onDegraded`
  * is called). Defaults to 5 seconds.
- * @param options.onBreak - A function which is called when the service fails
- * too many times in a row (specifically, more than `maxConsecutiveFailures`).
- * @param options.onDegraded - A function which is called when the service
- * succeeds before `maxConsecutiveFailures` is reached, but takes more time than
- * the `degradedThreshold` to run.
- * @param options.onRetry - A function which will be called the moment the
- * policy kicks off a timer to re-run the function passed to the policy. This is
- * primarily useful in tests where we are mocking timers.
  * @returns The service policy.
  * @example
  * This function is designed to be used in the context of a service class like
@@ -93,13 +91,7 @@ exports.DEFAULT_DEGRADED_THRESHOLD = 5000;
  * }
  * ```
  */
-function createServicePolicy({ maxRetries = exports.DEFAULT_MAX_RETRIES, retryFilterPolicy = cockatiel_1.handleAll, maxConsecutiveFailures = exports.DEFAULT_MAX_CONSECUTIVE_FAILURES, circuitBreakDuration = exports.DEFAULT_CIRCUIT_BREAK_DURATION, degradedThreshold = exports.DEFAULT_DEGRADED_THRESHOLD, onBreak = () => {
-    // do nothing
-}, onDegraded = () => {
-    // do nothing
-}, onRetry = () => {
-    // do nothing
-}, } = {}) {
+function createServicePolicy({ maxRetries = exports.DEFAULT_MAX_RETRIES, retryFilterPolicy = cockatiel_1.handleAll, maxConsecutiveFailures = exports.DEFAULT_MAX_CONSECUTIVE_FAILURES, circuitBreakDuration = exports.DEFAULT_CIRCUIT_BREAK_DURATION, degradedThreshold = exports.DEFAULT_DEGRADED_THRESHOLD, } = {}) {
     const retryPolicy = (0, cockatiel_1.retry)(retryFilterPolicy, {
         // Note that although the option here is called "max attempts", it's really
         // maximum number of *retries* (attempts past the initial attempt).
@@ -108,6 +100,7 @@ function createServicePolicy({ maxRetries = exports.DEFAULT_MAX_RETRIES, retryFi
         // determined by a backoff formula.
         backoff: new cockatiel_1.ExponentialBackoff(),
     });
+    const onRetry = retryPolicy.onRetry.bind(retryPolicy);
     const circuitBreakerPolicy = (0, cockatiel_1.circuitBreaker)(cockatiel_1.handleAll, {
         // While the circuit is open, any additional invocations of the service
         // passed to the policy (either via automatic retries or by manually
@@ -118,38 +111,37 @@ function createServicePolicy({ maxRetries = exports.DEFAULT_MAX_RETRIES, retryFi
         halfOpenAfter: circuitBreakDuration,
         breaker: new cockatiel_1.ConsecutiveBreaker(maxConsecutiveFailures),
     });
-    // The `onBreak` callback will be called if the service consistently throws
-    // for as many times as exceeds the maximum consecutive number of failures.
-    // Combined with the retry policy, this can happen if:
-    // - `maxConsecutiveFailures` < the default max retries (3) and the policy is
-    // executed once
-    // - `maxConsecutiveFailures` >= the default max retries (3) but the policy is
-    //   executed multiple times, enough for the total number of retries to exceed
-    //   `maxConsecutiveFailures`
-    circuitBreakerPolicy.onBreak(onBreak);
-    // The `onRetryPolicy` callback will be called each time the service is
-    // invoked (including retries).
-    retryPolicy.onRetry(onRetry);
+    const onBreak = circuitBreakerPolicy.onBreak.bind(circuitBreakerPolicy);
+    const onDegradedListeners = [];
     retryPolicy.onGiveUp(() => {
         if (circuitBreakerPolicy.state === cockatiel_1.CircuitState.Closed) {
-            // The `onDegraded` callback will be called if the number of retries is
-            // exceeded and the maximum number of consecutive failures has not been
-            // reached yet (whether the policy is called once or multiple times).
-            onDegraded();
+            for (const listener of onDegradedListeners) {
+                listener();
+            }
         }
     });
     retryPolicy.onSuccess(({ duration }) => {
         if (circuitBreakerPolicy.state === cockatiel_1.CircuitState.Closed &&
             duration > degradedThreshold) {
-            // The `onDegraded` callback will also be called if the service does not
-            // throw, but the time it takes for the service to run exceeds the
-            // `degradedThreshold`.
-            onDegraded();
+            for (const listener of onDegradedListeners) {
+                listener();
+            }
         }
     });
-    // The retry policy really retries the circuit breaker policy, which invokes
-    // the service.
-    return (0, cockatiel_1.wrap)(retryPolicy, circuitBreakerPolicy);
+    const onDegraded = (listener) => {
+        onDegradedListeners.push(listener);
+    };
+    // Every time the retry policy makes an attempt, it executes the circuit
+    // breaker policy, which executes the service.
+    const policy = (0, cockatiel_1.wrap)(retryPolicy, circuitBreakerPolicy);
+    return {
+        ...policy,
+        circuitBreakerPolicy,
+        retryPolicy,
+        onBreak,
+        onDegraded,
+        onRetry,
+    };
 }
 exports.createServicePolicy = createServicePolicy;
 //# sourceMappingURL=create-service-policy.cjs.map

package/dist/create-service-policy.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"create-service-policy.cjs","sourceRoot":"","sources":["../src/create-service-policy.ts"],"names":[],"mappings":";;;AAAA,yCAQmB;AAKnB;;;GAGG;AACU,QAAA,mBAAmB,GAAG,CAAC,CAAC;AAErC;;;GAGG;AACU,QAAA,gCAAgC,GAAG,CAAC,CAAC,GAAG,2BAAmB,CAAC,GAAG,CAAC,CAAC;AAE9E;;;GAGG;AACU,QAAA,8BAA8B,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;AAE7D;;;GAGG;AACU,QAAA,0BAA0B,GAAG,IAAK,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsEG;AACH,SAAgB,mBAAmB,CAAC,EAClC,UAAU,GAAG,2BAAmB,EAChC,iBAAiB,GAAG,qBAAS,EAC7B,sBAAsB,GAAG,wCAAgC,EACzD,oBAAoB,GAAG,sCAA8B,EACrD,iBAAiB,GAAG,kCAA0B,EAC9C,OAAO,GAAG,GAAG,EAAE;IACb,aAAa;AACf,CAAC,EACD,UAAU,GAAG,GAAG,EAAE;IAChB,aAAa;AACf,CAAC,EACD,OAAO,GAAG,GAAG,EAAE;IACb,aAAa;AACf,CAAC,MAUC,EAAE;IACJ,MAAM,WAAW,GAAG,IAAA,iBAAK,EAAC,iBAAiB,EAAE;QAC3C,2EAA2E;QAC3E,mEAAmE;QACnE,WAAW,EAAE,UAAU;QACvB,4EAA4E;QAC5E,mCAAmC;QACnC,OAAO,EAAE,IAAI,8BAAkB,EAAE;KAClC,CAAC,CAAC;IAEH,MAAM,oBAAoB,GAAG,IAAA,0BAAc,EAAC,qBAAS,EAAE;QACrD,uEAAuE;QACvE,oEAAoE;QACpE,wEAAwE;QACxE,4EAA4E;QAC5E,qEAAqE;QACrE,qDAAqD;QACrD,aAAa,EAAE,oBAAoB;QACnC,OAAO,EAAE,IAAI,8BAAkB,CAAC,sBAAsB,CAAC;KACxD,CAAC,CAAC;IAEH,2EAA2E;IAC3E,2EAA2E;IAC3E,sDAAsD;IACtD,6EAA6E;IAC7E,gBAAgB;IAChB,8EAA8E;IAC9E,8EAA8E;IAC9E,6BAA6B;IAC7B,oBAAoB,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IAEtC,uEAAuE;IACvE,+BAA+B;IAC/B,WAAW,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IAE7B,WAAW,CAAC,QAAQ,CAAC,GAAG,EAAE;QACxB,IAAI,oBAAoB,CAAC,KAAK,KAAK,wBAAY,CAAC,MAAM,EAAE;YACtD,uEAAuE;YACvE,uEAAuE;YACvE,qEAAqE;YACrE,UAAU,EAAE,CAAC;SACd;IACH,CAAC,CAAC,CAAC;IACH,WAAW,CAAC,SAAS,CAAC,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE;QACrC,IACE,oBAAoB,CAAC,KAAK,KAAK,wBAAY,CAAC,MAAM;YAClD,QAAQ,GAAG,iBAAiB,EAC5B;YACA,wEAAwE;YACxE,kEAAkE;YAClE,uBAAuB;YACvB,UAAU,EAAE,CAAC;SACd;IACH,CAAC,CAAC,CAAC;IAEH,4EAA4E;IAC5E,eAAe;IACf,OAAO,IAAA,gBAAI,EAAC,WAAW,EAAE,oBAAoB,CAAC,CAAC;AACjD,CAAC;AAlFD,kDAkFC","sourcesContent":["import {\n  circuitBreaker,\n  ConsecutiveBreaker,\n  ExponentialBackoff,\n  handleAll,\n  retry,\n  wrap,\n  CircuitState,\n} from 'cockatiel';\nimport type { IPolicy, Policy } from 'cockatiel';\n\nexport type { IPolicy as IServicePolicy };\n\n/**\n * The maximum number of times that a failing service should be re-run before\n * giving up.\n */\nexport const DEFAULT_MAX_RETRIES = 3;\n\n/**\n * The maximum number of times that the service is allowed to fail before\n * pausing further retries.\n */\nexport const DEFAULT_MAX_CONSECUTIVE_FAILURES = (1 + DEFAULT_MAX_RETRIES) * 3;\n\n/**\n * The default length of time (in milliseconds) to temporarily pause retries of\n * the service after enough consecutive failures.\n */\nexport const DEFAULT_CIRCUIT_BREAK_DURATION = 30 * 60 * 1000;\n\n/**\n * The default length of time (in milliseconds) that governs when the service is\n * regarded as degraded (affecting when `onDegraded` is called).\n */\nexport const DEFAULT_DEGRADED_THRESHOLD = 5_000;\n\n/**\n * Constructs an object exposing an `execute` method which, given a function —\n * hereafter called the \"service\" — will retry that service with ever increasing\n * delays until it succeeds. If the policy detects too many consecutive\n * failures, it will block further retries until a designated time period has\n * passed; this particular behavior is primarily designed for services that wrap\n * API calls so as not to make needless HTTP requests when the API is down and\n * to be able to recover when the API comes back up. In addition, hooks allow\n * for responding to certain events, one of which can be used to detect when an\n * HTTP request is performing slowly.\n *\n * Internally, this function makes use of the retry and circuit breaker policies\n * from the [Cockatiel](https://www.npmjs.com/package/cockatiel) library; see\n * there for more.\n *\n * @param options - The options to this function.\n * @param options.maxRetries - The maximum number of times that a failing\n * service should be re-invoked before giving up. Defaults to 3.\n * @param options.retryFilterPolicy - The policy used to control when the\n * service should be retried based on either the result of the servce or an\n * error that it throws. For instance, you could use this to retry only certain\n * errors. See `handleWhen` and friends from Cockatiel for more.\n * @param options.maxConsecutiveFailures - The maximum number of times that the\n * service is allowed to fail before pausing further retries. Defaults to 12.\n * @param options.circuitBreakDuration - The length of time (in milliseconds) to\n * pause retries of the action after the number of failures reaches\n * `maxConsecutiveFailures`.\n * @param options.degradedThreshold - The length of time (in milliseconds) that\n * governs when the service is regarded as degraded (affecting when `onDegraded`\n * is called). Defaults to 5 seconds.\n * @param options.onBreak - A function which is called when the service fails\n * too many times in a row (specifically, more than `maxConsecutiveFailures`).\n * @param options.onDegraded - A function which is called when the service\n * succeeds before `maxConsecutiveFailures` is reached, but takes more time than\n * the `degradedThreshold` to run.\n * @param options.onRetry - A function which will be called the moment the\n * policy kicks off a timer to re-run the function passed to the policy. This is\n * primarily useful in tests where we are mocking timers.\n * @returns The service policy.\n * @example\n * This function is designed to be used in the context of a service class like\n * this:\n * ``` ts\n * class Service {\n *   constructor() {\n *     this.#policy = createServicePolicy({\n *       maxRetries: 3,\n *       retryFilterPolicy: handleWhen((error) => {\n *         return error.message.includes('oops');\n *       }),\n *       maxConsecutiveFailures: 3,\n *       circuitBreakDuration: 5000,\n *       degradedThreshold: 2000,\n *       onBreak: () => {\n *         console.log('Circuit broke');\n *       },\n *       onDegraded: () => {\n *         console.log('Service is degraded');\n *       },\n *     });\n *   }\n *\n *   async fetch() {\n *     return await this.#policy.execute(async () => {\n *       const response = await fetch('https://some/url');\n *       return await response.json();\n *     });\n *   }\n * }\n * ```\n */\nexport function createServicePolicy({\n  maxRetries = DEFAULT_MAX_RETRIES,\n  retryFilterPolicy = handleAll,\n  maxConsecutiveFailures = DEFAULT_MAX_CONSECUTIVE_FAILURES,\n  circuitBreakDuration = DEFAULT_CIRCUIT_BREAK_DURATION,\n  degradedThreshold = DEFAULT_DEGRADED_THRESHOLD,\n  onBreak = () => {\n    // do nothing\n  },\n  onDegraded = () => {\n    // do nothing\n  },\n  onRetry = () => {\n    // do nothing\n  },\n}: {\n  maxRetries?: number;\n  retryFilterPolicy?: Policy;\n  maxConsecutiveFailures?: number;\n  circuitBreakDuration?: number;\n  degradedThreshold?: number;\n  onBreak?: () => void;\n  onDegraded?: () => void;\n  onRetry?: () => void;\n} = {}): IPolicy {\n  const retryPolicy = retry(retryFilterPolicy, {\n    // Note that although the option here is called \"max attempts\", it's really\n    // maximum number of *retries* (attempts past the initial attempt).\n    maxAttempts: maxRetries,\n    // Retries of the service will be executed following ever increasing delays,\n    // determined by a backoff formula.\n    backoff: new ExponentialBackoff(),\n  });\n\n  const circuitBreakerPolicy = circuitBreaker(handleAll, {\n    // While the circuit is open, any additional invocations of the service\n    // passed to the policy (either via automatic retries or by manually\n    // executing the policy again) will result in a BrokenCircuitError. This\n    // will remain the case until `circuitBreakDuration` passes, after which the\n    // service will be allowed to run again. If the service succeeds, the\n    // circuit will close, otherwise it will remain open.\n    halfOpenAfter: circuitBreakDuration,\n    breaker: new ConsecutiveBreaker(maxConsecutiveFailures),\n  });\n\n  // The `onBreak` callback will be called if the service consistently throws\n  // for as many times as exceeds the maximum consecutive number of failures.\n  // Combined with the retry policy, this can happen if:\n  // - `maxConsecutiveFailures` < the default max retries (3) and the policy is\n  // executed once\n  // - `maxConsecutiveFailures` >= the default max retries (3) but the policy is\n  //   executed multiple times, enough for the total number of retries to exceed\n  //   `maxConsecutiveFailures`\n  circuitBreakerPolicy.onBreak(onBreak);\n\n  // The `onRetryPolicy` callback will be called each time the service is\n  // invoked (including retries).\n  retryPolicy.onRetry(onRetry);\n\n  retryPolicy.onGiveUp(() => {\n    if (circuitBreakerPolicy.state === CircuitState.Closed) {\n      // The `onDegraded` callback will be called if the number of retries is\n      // exceeded and the maximum number of consecutive failures has not been\n      // reached yet (whether the policy is called once or multiple times).\n      onDegraded();\n    }\n  });\n  retryPolicy.onSuccess(({ duration }) => {\n    if (\n      circuitBreakerPolicy.state === CircuitState.Closed &&\n      duration > degradedThreshold\n    ) {\n      // The `onDegraded` callback will also be called if the service does not\n      // throw, but the time it takes for the service to run exceeds the\n      // `degradedThreshold`.\n      onDegraded();\n    }\n  });\n\n  // The retry policy really retries the circuit breaker policy, which invokes\n  // the service.\n  return wrap(retryPolicy, circuitBreakerPolicy);\n}\n"]}
+{"version":3,"file":"create-service-policy.cjs","sourceRoot":"","sources":["../src/create-service-policy.ts"],"names":[],"mappings":";;;AAAA,yCAUmB;AAQI,mGAjBrB,8BAAkB,OAiBqB;AAAhC,6FAhBP,wBAAY,OAgBO;AAAsB,0FAZzC,qBAAS,OAYyC;AAAE,2FAXpD,sBAAU,OAWoD;AAqEhE;;;GAGG;AACU,QAAA,mBAAmB,GAAG,CAAC,CAAC;AAErC;;;;;GAKG;AACU,QAAA,gCAAgC,GAAG,CAAC,CAAC,GAAG,2BAAmB,CAAC,GAAG,CAAC,CAAC;AAE9E;;;GAGG;AACU,QAAA,8BAA8B,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;AAE7D;;;GAGG;AACU,QAAA,0BAA0B,GAAG,IAAK,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,SAAgB,mBAAmB,CAAC,EAClC,UAAU,GAAG,2BAAmB,EAChC,iBAAiB,GAAG,qBAAS,EAC7B,sBAAsB,GAAG,wCAAgC,EACzD,oBAAoB,GAAG,sCAA8B,EACrD,iBAAiB,GAAG,kCAA0B,MAChB,EAAE;IAChC,MAAM,WAAW,GAAG,IAAA,iBAAK,EAAC,iBAAiB,EAAE;QAC3C,2EAA2E;QAC3E,mEAAmE;QACnE,WAAW,EAAE,UAAU;QACvB,4EAA4E;QAC5E,mCAAmC;QACnC,OAAO,EAAE,IAAI,8BAAkB,EAAE;KAClC,CAAC,CAAC;IACH,MAAM,OAAO,GAAG,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAEtD,MAAM,oBAAoB,GAAG,IAAA,0BAAc,EAAC,qBAAS,EAAE;QACrD,uEAAuE;QACvE,oEAAoE;QACpE,wEAAwE;QACxE,4EAA4E;QAC5E,qEAAqE;QACrE,qDAAqD;QACrD,aAAa,EAAE,oBAAoB;QACnC,OAAO,EAAE,IAAI,8BAAkB,CAAC,sBAAsB,CAAC;KACxD,CAAC,CAAC;IACH,MAAM,OAAO,GAAG,oBAAoB,CAAC,OAAO,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;IAExE,MAAM,mBAAmB,GAAmB,EAAE,CAAC;IAC/C,WAAW,CAAC,QAAQ,CAAC,GAAG,EAAE;QACxB,IAAI,oBAAoB,CAAC,KAAK,KAAK,wBAAY,CAAC,MAAM,EAAE;YACtD,KAAK,MAAM,QAAQ,IAAI,mBAAmB,EAAE;gBAC1C,QAAQ,EAAE,CAAC;aACZ;SACF;IACH,CAAC,CAAC,CAAC;IACH,WAAW,CAAC,SAAS,CAAC,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE;QACrC,IACE,oBAAoB,CAAC,KAAK,KAAK,wBAAY,CAAC,MAAM;YAClD,QAAQ,GAAG,iBAAiB,EAC5B;YACA,KAAK,MAAM,QAAQ,IAAI,mBAAmB,EAAE;gBAC1C,QAAQ,EAAE,CAAC;aACZ;SACF;IACH,CAAC,CAAC,CAAC;IACH,MAAM,UAAU,GAAG,CAAC,QAAoB,EAAE,EAAE;QAC1C,mBAAmB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IACrC,CAAC,CAAC;IAEF,wEAAwE;IACxE,8CAA8C;IAC9C,MAAM,MAAM,GAAG,IAAA,gBAAI,EAAC,WAAW,EAAE,oBAAoB,CAAC,CAAC;IAEvD,OAAO;QACL,GAAG,MAAM;QACT,oBAAoB;QACpB,WAAW;QACX,OAAO;QACP,UAAU;QACV,OAAO;KACR,CAAC;AACJ,CAAC;AA/DD,kDA+DC","sourcesContent":["import {\n  BrokenCircuitError,\n  CircuitState,\n  ConsecutiveBreaker,\n  ExponentialBackoff,\n  circuitBreaker,\n  handleAll,\n  handleWhen,\n  retry,\n  wrap,\n} from 'cockatiel';\nimport type {\n  CircuitBreakerPolicy,\n  IPolicy,\n  Policy,\n  RetryPolicy,\n} from 'cockatiel';\n\nexport { CircuitState, BrokenCircuitError, handleAll, handleWhen };\n\n/**\n * The options for `createServicePolicy`.\n */\nexport type CreateServicePolicyOptions = {\n  /**\n   * The length of time (in milliseconds) to pause retries of the action after\n   * the number of failures reaches `maxConsecutiveFailures`.\n   */\n  circuitBreakDuration?: number;\n  /**\n   * The length of time (in milliseconds) that governs when the service is\n   * regarded as degraded (affecting when `onDegraded` is called).\n   */\n  degradedThreshold?: number;\n  /**\n   * The maximum number of times that the service is allowed to fail before\n   * pausing further retries.\n   */\n  maxConsecutiveFailures?: number;\n  /**\n   * The maximum number of times that a failing service should be re-invoked\n   * before giving up.\n   */\n  maxRetries?: number;\n  /**\n   * The policy used to control when the service should be retried based on\n   * either the result of the service or an error that it throws. For instance,\n   * you could use this to retry only certain errors. See `handleWhen` and\n   * friends from Cockatiel for more.\n   */\n  retryFilterPolicy?: Policy;\n};\n\n/**\n * The service policy object.\n */\nexport type ServicePolicy = IPolicy & {\n  /**\n   * The Cockatiel circuit breaker policy that the service policy uses\n   * internally.\n   */\n  circuitBreakerPolicy: CircuitBreakerPolicy;\n  /**\n   * The Cockatiel retry policy that the service policy uses internally.\n   */\n  retryPolicy: RetryPolicy;\n  /**\n   * A function which is called when the number of times that the service fails\n   * in a row meets the set maximum number of consecutive failures.\n   */\n  onBreak: CircuitBreakerPolicy['onBreak'];\n  /**\n   * A function which is called in two circumstances: 1) when the service\n   * succeeds before the maximum number of consecutive failures is reached, but\n   * takes more time than the `degradedThreshold` to run, or 2) if the service\n   * never succeeds before the retry policy gives up and before the maximum\n   * number of consecutive failures has been reached.\n   */\n  onDegraded: (fn: () => void) => void;\n  /**\n   * A function which will be called by the retry policy each time the service\n   * fails and the policy kicks off a timer to re-run the service. This is\n   * primarily useful in tests where we are mocking timers.\n   */\n  onRetry: RetryPolicy['onRetry'];\n};\n\n/**\n * The maximum number of times that a failing service should be re-run before\n * giving up.\n */\nexport const DEFAULT_MAX_RETRIES = 3;\n\n/**\n * The maximum number of times that the service is allowed to fail before\n * pausing further retries. This is set to a value such that if given a\n * service that continually fails, the policy needs to be executed 3 times\n * before further retries are paused.\n */\nexport const DEFAULT_MAX_CONSECUTIVE_FAILURES = (1 + DEFAULT_MAX_RETRIES) * 3;\n\n/**\n * The default length of time (in milliseconds) to temporarily pause retries of\n * the service after enough consecutive failures.\n */\nexport const DEFAULT_CIRCUIT_BREAK_DURATION = 30 * 60 * 1000;\n\n/**\n * The default length of time (in milliseconds) that governs when the service is\n * regarded as degraded (affecting when `onDegraded` is called).\n */\nexport const DEFAULT_DEGRADED_THRESHOLD = 5_000;\n\n/**\n * Constructs an object exposing an `execute` method which, given a function —\n * hereafter called the \"service\" — will retry that service with ever increasing\n * delays until it succeeds. If the policy detects too many consecutive\n * failures, it will block further retries until a designated time period has\n * passed; this particular behavior is primarily designed for services that wrap\n * API calls so as not to make needless HTTP requests when the API is down and\n * to be able to recover when the API comes back up. In addition, hooks allow\n * for responding to certain events, one of which can be used to detect when an\n * HTTP request is performing slowly.\n *\n * Internally, this function makes use of the retry and circuit breaker policies\n * from the [Cockatiel](https://www.npmjs.com/package/cockatiel) library; see\n * there for more.\n *\n * @param options - The options to this function.\n * @param options.maxRetries - The maximum number of times that a failing\n * service should be re-invoked before giving up. Defaults to 3.\n * @param options.retryFilterPolicy - The policy used to control when the\n * service should be retried based on either the result of the servce or an\n * error that it throws. For instance, you could use this to retry only certain\n * errors. See `handleWhen` and friends from Cockatiel for more.\n * @param options.maxConsecutiveFailures - The maximum number of times that the\n * service is allowed to fail before pausing further retries. Defaults to 12.\n * @param options.circuitBreakDuration - The length of time (in milliseconds) to\n * pause retries of the action after the number of failures reaches\n * `maxConsecutiveFailures`.\n * @param options.degradedThreshold - The length of time (in milliseconds) that\n * governs when the service is regarded as degraded (affecting when `onDegraded`\n * is called). Defaults to 5 seconds.\n * @returns The service policy.\n * @example\n * This function is designed to be used in the context of a service class like\n * this:\n * ``` ts\n * class Service {\n *   constructor() {\n *     this.#policy = createServicePolicy({\n *       maxRetries: 3,\n *       retryFilterPolicy: handleWhen((error) => {\n *         return error.message.includes('oops');\n *       }),\n *       maxConsecutiveFailures: 3,\n *       circuitBreakDuration: 5000,\n *       degradedThreshold: 2000,\n *       onBreak: () => {\n *         console.log('Circuit broke');\n *       },\n *       onDegraded: () => {\n *         console.log('Service is degraded');\n *       },\n *     });\n *   }\n *\n *   async fetch() {\n *     return await this.#policy.execute(async () => {\n *       const response = await fetch('https://some/url');\n *       return await response.json();\n *     });\n *   }\n * }\n * ```\n */\nexport function createServicePolicy({\n  maxRetries = DEFAULT_MAX_RETRIES,\n  retryFilterPolicy = handleAll,\n  maxConsecutiveFailures = DEFAULT_MAX_CONSECUTIVE_FAILURES,\n  circuitBreakDuration = DEFAULT_CIRCUIT_BREAK_DURATION,\n  degradedThreshold = DEFAULT_DEGRADED_THRESHOLD,\n}: CreateServicePolicyOptions = {}): ServicePolicy {\n  const retryPolicy = retry(retryFilterPolicy, {\n    // Note that although the option here is called \"max attempts\", it's really\n    // maximum number of *retries* (attempts past the initial attempt).\n    maxAttempts: maxRetries,\n    // Retries of the service will be executed following ever increasing delays,\n    // determined by a backoff formula.\n    backoff: new ExponentialBackoff(),\n  });\n  const onRetry = retryPolicy.onRetry.bind(retryPolicy);\n\n  const circuitBreakerPolicy = circuitBreaker(handleAll, {\n    // While the circuit is open, any additional invocations of the service\n    // passed to the policy (either via automatic retries or by manually\n    // executing the policy again) will result in a BrokenCircuitError. This\n    // will remain the case until `circuitBreakDuration` passes, after which the\n    // service will be allowed to run again. If the service succeeds, the\n    // circuit will close, otherwise it will remain open.\n    halfOpenAfter: circuitBreakDuration,\n    breaker: new ConsecutiveBreaker(maxConsecutiveFailures),\n  });\n  const onBreak = circuitBreakerPolicy.onBreak.bind(circuitBreakerPolicy);\n\n  const onDegradedListeners: (() => void)[] = [];\n  retryPolicy.onGiveUp(() => {\n    if (circuitBreakerPolicy.state === CircuitState.Closed) {\n      for (const listener of onDegradedListeners) {\n        listener();\n      }\n    }\n  });\n  retryPolicy.onSuccess(({ duration }) => {\n    if (\n      circuitBreakerPolicy.state === CircuitState.Closed &&\n      duration > degradedThreshold\n    ) {\n      for (const listener of onDegradedListeners) {\n        listener();\n      }\n    }\n  });\n  const onDegraded = (listener: () => void) => {\n    onDegradedListeners.push(listener);\n  };\n\n  // Every time the retry policy makes an attempt, it executes the circuit\n  // breaker policy, which executes the service.\n  const policy = wrap(retryPolicy, circuitBreakerPolicy);\n\n  return {\n    ...policy,\n    circuitBreakerPolicy,\n    retryPolicy,\n    onBreak,\n    onDegraded,\n    onRetry,\n  };\n}\n"]}

package/dist/create-service-policy.d.cts

@@ -1,5 +1,71 @@
-import type { IPolicy, Policy } from "cockatiel";
-export type { IPolicy as IServicePolicy };
+import { BrokenCircuitError, CircuitState, handleAll, handleWhen } from "cockatiel";
+import type { CircuitBreakerPolicy, IPolicy, Policy, RetryPolicy } from "cockatiel";
+export { CircuitState, BrokenCircuitError, handleAll, handleWhen };
+/**
+ * The options for `createServicePolicy`.
+ */
+export type CreateServicePolicyOptions = {
+    /**
+     * The length of time (in milliseconds) to pause retries of the action after
+     * the number of failures reaches `maxConsecutiveFailures`.
+     */
+    circuitBreakDuration?: number;
+    /**
+     * The length of time (in milliseconds) that governs when the service is
+     * regarded as degraded (affecting when `onDegraded` is called).
+     */
+    degradedThreshold?: number;
+    /**
+     * The maximum number of times that the service is allowed to fail before
+     * pausing further retries.
+     */
+    maxConsecutiveFailures?: number;
+    /**
+     * The maximum number of times that a failing service should be re-invoked
+     * before giving up.
+     */
+    maxRetries?: number;
+    /**
+     * The policy used to control when the service should be retried based on
+     * either the result of the service or an error that it throws. For instance,
+     * you could use this to retry only certain errors. See `handleWhen` and
+     * friends from Cockatiel for more.
+     */
+    retryFilterPolicy?: Policy;
+};
+/**
+ * The service policy object.
+ */
+export type ServicePolicy = IPolicy & {
+    /**
+     * The Cockatiel circuit breaker policy that the service policy uses
+     * internally.
+     */
+    circuitBreakerPolicy: CircuitBreakerPolicy;
+    /**
+     * The Cockatiel retry policy that the service policy uses internally.
+     */
+    retryPolicy: RetryPolicy;
+    /**
+     * A function which is called when the number of times that the service fails
+     * in a row meets the set maximum number of consecutive failures.
+     */
+    onBreak: CircuitBreakerPolicy['onBreak'];
+    /**
+     * A function which is called in two circumstances: 1) when the service
+     * succeeds before the maximum number of consecutive failures is reached, but
+     * takes more time than the `degradedThreshold` to run, or 2) if the service
+     * never succeeds before the retry policy gives up and before the maximum
+     * number of consecutive failures has been reached.
+     */
+    onDegraded: (fn: () => void) => void;
+    /**
+     * A function which will be called by the retry policy each time the service
+     * fails and the policy kicks off a timer to re-run the service. This is
+     * primarily useful in tests where we are mocking timers.
+     */
+    onRetry: RetryPolicy['onRetry'];
+};
 /**
  * The maximum number of times that a failing service should be re-run before
  * giving up.
@@ -7,7 +73,9 @@ export type { IPolicy as IServicePolicy };
 export declare const DEFAULT_MAX_RETRIES = 3;
 /**
  * The maximum number of times that the service is allowed to fail before
- * pausing further retries.
+ * pausing further retries. This is set to a value such that if given a
+ * service that continually fails, the policy needs to be executed 3 times
+ * before further retries are paused.
  */
 export declare const DEFAULT_MAX_CONSECUTIVE_FAILURES: number;
 /**
@@ -50,14 +118,6 @@ export declare const DEFAULT_DEGRADED_THRESHOLD = 5000;
  * @param options.degradedThreshold - The length of time (in milliseconds) that
  * governs when the service is regarded as degraded (affecting when `onDegraded`
  * is called). Defaults to 5 seconds.
- * @param options.onBreak - A function which is called when the service fails
- * too many times in a row (specifically, more than `maxConsecutiveFailures`).
- * @param options.onDegraded - A function which is called when the service
- * succeeds before `maxConsecutiveFailures` is reached, but takes more time than
- * the `degradedThreshold` to run.
- * @param options.onRetry - A function which will be called the moment the
- * policy kicks off a timer to re-run the function passed to the policy. This is
- * primarily useful in tests where we are mocking timers.
  * @returns The service policy.
  * @example
  * This function is designed to be used in the context of a service class like
@@ -91,14 +151,5 @@ export declare const DEFAULT_DEGRADED_THRESHOLD = 5000;
  * }
  * ```
  */
-export declare function createServicePolicy({ maxRetries, retryFilterPolicy, maxConsecutiveFailures, circuitBreakDuration, degradedThreshold, onBreak, onDegraded, onRetry, }?: {
-    maxRetries?: number;
-    retryFilterPolicy?: Policy;
-    maxConsecutiveFailures?: number;
-    circuitBreakDuration?: number;
-    degradedThreshold?: number;
-    onBreak?: () => void;
-    onDegraded?: () => void;
-    onRetry?: () => void;
-}): IPolicy;
+export declare function createServicePolicy({ maxRetries, retryFilterPolicy, maxConsecutiveFailures, circuitBreakDuration, degradedThreshold, }?: CreateServicePolicyOptions): ServicePolicy;
 //# sourceMappingURL=create-service-policy.d.cts.map

package/dist/create-service-policy.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"create-service-policy.d.cts","sourceRoot":"","sources":["../src/create-service-policy.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,kBAAkB;AAEjD,YAAY,EAAE,OAAO,IAAI,cAAc,EAAE,CAAC;AAE1C;;;GAGG;AACH,eAAO,MAAM,mBAAmB,IAAI,CAAC;AAErC;;;GAGG;AACH,eAAO,MAAM,gCAAgC,QAAgC,CAAC;AAE9E;;;GAGG;AACH,eAAO,MAAM,8BAA8B,QAAiB,CAAC;AAE7D;;;GAGG;AACH,eAAO,MAAM,0BAA0B,OAAQ,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsEG;AACH,wBAAgB,mBAAmB,CAAC,EAClC,UAAgC,EAChC,iBAA6B,EAC7B,sBAAyD,EACzD,oBAAqD,EACrD,iBAA8C,EAC9C,OAEC,EACD,UAEC,EACD,OAEC,GACF,GAAE;IACD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,IAAI,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;CACjB,GAAG,OAAO,CA0Df"}
+{"version":3,"file":"create-service-policy.d.cts","sourceRoot":"","sources":["../src/create-service-policy.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,YAAY,EAIZ,SAAS,EACT,UAAU,EAGX,kBAAkB;AACnB,OAAO,KAAK,EACV,oBAAoB,EACpB,OAAO,EACP,MAAM,EACN,WAAW,EACZ,kBAAkB;AAEnB,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,SAAS,EAAE,UAAU,EAAE,CAAC;AAEnE;;GAEG;AACH,MAAM,MAAM,0BAA0B,GAAG;IACvC;;;OAGG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;;OAGG;IACH,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG;IACpC;;;OAGG;IACH,oBAAoB,EAAE,oBAAoB,CAAC;IAC3C;;OAEG;IACH,WAAW,EAAE,WAAW,CAAC;IACzB;;;OAGG;IACH,OAAO,EAAE,oBAAoB,CAAC,SAAS,CAAC,CAAC;IACzC;;;;;;OAMG;IACH,UAAU,EAAE,CAAC,EAAE,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC;IACrC;;;;OAIG;IACH,OAAO,EAAE,WAAW,CAAC,SAAS,CAAC,CAAC;CACjC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,mBAAmB,IAAI,CAAC;AAErC;;;;;GAKG;AACH,eAAO,MAAM,gCAAgC,QAAgC,CAAC;AAE9E;;;GAGG;AACH,eAAO,MAAM,8BAA8B,QAAiB,CAAC;AAE7D;;;GAGG;AACH,eAAO,MAAM,0BAA0B,OAAQ,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,wBAAgB,mBAAmB,CAAC,EAClC,UAAgC,EAChC,iBAA6B,EAC7B,sBAAyD,EACzD,oBAAqD,EACrD,iBAA8C,GAC/C,GAAE,0BAA+B,GAAG,aAAa,CAyDjD"}

package/dist/create-service-policy.d.mts

@@ -1,5 +1,71 @@
-import type { IPolicy, Policy } from "cockatiel";
-export type { IPolicy as IServicePolicy };
+import { BrokenCircuitError, CircuitState, handleAll, handleWhen } from "cockatiel";
+import type { CircuitBreakerPolicy, IPolicy, Policy, RetryPolicy } from "cockatiel";
+export { CircuitState, BrokenCircuitError, handleAll, handleWhen };
+/**
+ * The options for `createServicePolicy`.
+ */
+export type CreateServicePolicyOptions = {
+    /**
+     * The length of time (in milliseconds) to pause retries of the action after
+     * the number of failures reaches `maxConsecutiveFailures`.
+     */
+    circuitBreakDuration?: number;
+    /**
+     * The length of time (in milliseconds) that governs when the service is
+     * regarded as degraded (affecting when `onDegraded` is called).
+     */
+    degradedThreshold?: number;
+    /**
+     * The maximum number of times that the service is allowed to fail before
+     * pausing further retries.
+     */
+    maxConsecutiveFailures?: number;
+    /**
+     * The maximum number of times that a failing service should be re-invoked
+     * before giving up.
+     */
+    maxRetries?: number;
+    /**
+     * The policy used to control when the service should be retried based on
+     * either the result of the service or an error that it throws. For instance,
+     * you could use this to retry only certain errors. See `handleWhen` and
+     * friends from Cockatiel for more.
+     */
+    retryFilterPolicy?: Policy;
+};
+/**
+ * The service policy object.
+ */
+export type ServicePolicy = IPolicy & {
+    /**
+     * The Cockatiel circuit breaker policy that the service policy uses
+     * internally.
+     */
+    circuitBreakerPolicy: CircuitBreakerPolicy;
+    /**
+     * The Cockatiel retry policy that the service policy uses internally.
+     */
+    retryPolicy: RetryPolicy;
+    /**
+     * A function which is called when the number of times that the service fails
+     * in a row meets the set maximum number of consecutive failures.
+     */
+    onBreak: CircuitBreakerPolicy['onBreak'];
+    /**
+     * A function which is called in two circumstances: 1) when the service
+     * succeeds before the maximum number of consecutive failures is reached, but
+     * takes more time than the `degradedThreshold` to run, or 2) if the service
+     * never succeeds before the retry policy gives up and before the maximum
+     * number of consecutive failures has been reached.
+     */
+    onDegraded: (fn: () => void) => void;
+    /**
+     * A function which will be called by the retry policy each time the service
+     * fails and the policy kicks off a timer to re-run the service. This is
+     * primarily useful in tests where we are mocking timers.
+     */
+    onRetry: RetryPolicy['onRetry'];
+};
 /**
  * The maximum number of times that a failing service should be re-run before
  * giving up.
@@ -7,7 +73,9 @@ export type { IPolicy as IServicePolicy };
 export declare const DEFAULT_MAX_RETRIES = 3;
 /**
  * The maximum number of times that the service is allowed to fail before
- * pausing further retries.
+ * pausing further retries. This is set to a value such that if given a
+ * service that continually fails, the policy needs to be executed 3 times
+ * before further retries are paused.
  */
 export declare const DEFAULT_MAX_CONSECUTIVE_FAILURES: number;
 /**
@@ -50,14 +118,6 @@ export declare const DEFAULT_DEGRADED_THRESHOLD = 5000;
  * @param options.degradedThreshold - The length of time (in milliseconds) that
  * governs when the service is regarded as degraded (affecting when `onDegraded`
  * is called). Defaults to 5 seconds.
- * @param options.onBreak - A function which is called when the service fails
- * too many times in a row (specifically, more than `maxConsecutiveFailures`).
- * @param options.onDegraded - A function which is called when the service
- * succeeds before `maxConsecutiveFailures` is reached, but takes more time than
- * the `degradedThreshold` to run.
- * @param options.onRetry - A function which will be called the moment the
- * policy kicks off a timer to re-run the function passed to the policy. This is
- * primarily useful in tests where we are mocking timers.
  * @returns The service policy.
  * @example
  * This function is designed to be used in the context of a service class like
@@ -91,14 +151,5 @@ export declare const DEFAULT_DEGRADED_THRESHOLD = 5000;
  * }
  * ```
  */
-export declare function createServicePolicy({ maxRetries, retryFilterPolicy, maxConsecutiveFailures, circuitBreakDuration, degradedThreshold, onBreak, onDegraded, onRetry, }?: {
-    maxRetries?: number;
-    retryFilterPolicy?: Policy;
-    maxConsecutiveFailures?: number;
-    circuitBreakDuration?: number;
-    degradedThreshold?: number;
-    onBreak?: () => void;
-    onDegraded?: () => void;
-    onRetry?: () => void;
-}): IPolicy;
+export declare function createServicePolicy({ maxRetries, retryFilterPolicy, maxConsecutiveFailures, circuitBreakDuration, degradedThreshold, }?: CreateServicePolicyOptions): ServicePolicy;
 //# sourceMappingURL=create-service-policy.d.mts.map

package/dist/create-service-policy.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"create-service-policy.d.mts","sourceRoot":"","sources":["../src/create-service-policy.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,kBAAkB;AAEjD,YAAY,EAAE,OAAO,IAAI,cAAc,EAAE,CAAC;AAE1C;;;GAGG;AACH,eAAO,MAAM,mBAAmB,IAAI,CAAC;AAErC;;;GAGG;AACH,eAAO,MAAM,gCAAgC,QAAgC,CAAC;AAE9E;;;GAGG;AACH,eAAO,MAAM,8BAA8B,QAAiB,CAAC;AAE7D;;;GAGG;AACH,eAAO,MAAM,0BAA0B,OAAQ,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsEG;AACH,wBAAgB,mBAAmB,CAAC,EAClC,UAAgC,EAChC,iBAA6B,EAC7B,sBAAyD,EACzD,oBAAqD,EACrD,iBAA8C,EAC9C,OAEC,EACD,UAEC,EACD,OAEC,GACF,GAAE;IACD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,IAAI,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;CACjB,GAAG,OAAO,CA0Df"}
+{"version":3,"file":"create-service-policy.d.mts","sourceRoot":"","sources":["../src/create-service-policy.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,YAAY,EAIZ,SAAS,EACT,UAAU,EAGX,kBAAkB;AACnB,OAAO,KAAK,EACV,oBAAoB,EACpB,OAAO,EACP,MAAM,EACN,WAAW,EACZ,kBAAkB;AAEnB,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,SAAS,EAAE,UAAU,EAAE,CAAC;AAEnE;;GAEG;AACH,MAAM,MAAM,0BAA0B,GAAG;IACvC;;;OAGG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;;OAGG;IACH,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG;IACpC;;;OAGG;IACH,oBAAoB,EAAE,oBAAoB,CAAC;IAC3C;;OAEG;IACH,WAAW,EAAE,WAAW,CAAC;IACzB;;;OAGG;IACH,OAAO,EAAE,oBAAoB,CAAC,SAAS,CAAC,CAAC;IACzC;;;;;;OAMG;IACH,UAAU,EAAE,CAAC,EAAE,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC;IACrC;;;;OAIG;IACH,OAAO,EAAE,WAAW,CAAC,SAAS,CAAC,CAAC;CACjC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,mBAAmB,IAAI,CAAC;AAErC;;;;;GAKG;AACH,eAAO,MAAM,gCAAgC,QAAgC,CAAC;AAE9E;;;GAGG;AACH,eAAO,MAAM,8BAA8B,QAAiB,CAAC;AAE7D;;;GAGG;AACH,eAAO,MAAM,0BAA0B,OAAQ,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,wBAAgB,mBAAmB,CAAC,EAClC,UAAgC,EAChC,iBAA6B,EAC7B,sBAAyD,EACzD,oBAAqD,EACrD,iBAA8C,GAC/C,GAAE,0BAA+B,GAAG,aAAa,CAyDjD"}

package/dist/create-service-policy.mjs

@@ -1,4 +1,5 @@
-import { circuitBreaker, ConsecutiveBreaker, ExponentialBackoff, handleAll, retry, wrap, CircuitState } from "cockatiel";
+import { BrokenCircuitError, CircuitState, ConsecutiveBreaker, ExponentialBackoff, circuitBreaker, handleAll, handleWhen, retry, wrap } from "cockatiel";
+export { CircuitState, BrokenCircuitError, handleAll, handleWhen };
 /**
  * The maximum number of times that a failing service should be re-run before
  * giving up.
@@ -6,7 +7,9 @@ import { circuitBreaker, ConsecutiveBreaker, ExponentialBackoff, handleAll, retr
 export const DEFAULT_MAX_RETRIES = 3;
 /**
  * The maximum number of times that the service is allowed to fail before
- * pausing further retries.
+ * pausing further retries. This is set to a value such that if given a
+ * service that continually fails, the policy needs to be executed 3 times
+ * before further retries are paused.
  */
 export const DEFAULT_MAX_CONSECUTIVE_FAILURES = (1 + DEFAULT_MAX_RETRIES) * 3;
 /**
@@ -49,14 +52,6 @@ export const DEFAULT_DEGRADED_THRESHOLD = 5000;
  * @param options.degradedThreshold - The length of time (in milliseconds) that
  * governs when the service is regarded as degraded (affecting when `onDegraded`
  * is called). Defaults to 5 seconds.
- * @param options.onBreak - A function which is called when the service fails
- * too many times in a row (specifically, more than `maxConsecutiveFailures`).
- * @param options.onDegraded - A function which is called when the service
- * succeeds before `maxConsecutiveFailures` is reached, but takes more time than
- * the `degradedThreshold` to run.
- * @param options.onRetry - A function which will be called the moment the
- * policy kicks off a timer to re-run the function passed to the policy. This is
- * primarily useful in tests where we are mocking timers.
  * @returns The service policy.
  * @example
  * This function is designed to be used in the context of a service class like
@@ -90,13 +85,7 @@ export const DEFAULT_DEGRADED_THRESHOLD = 5000;
  * }
  * ```
  */
-export function createServicePolicy({ maxRetries = DEFAULT_MAX_RETRIES, retryFilterPolicy = handleAll, maxConsecutiveFailures = DEFAULT_MAX_CONSECUTIVE_FAILURES, circuitBreakDuration = DEFAULT_CIRCUIT_BREAK_DURATION, degradedThreshold = DEFAULT_DEGRADED_THRESHOLD, onBreak = () => {
-    // do nothing
-}, onDegraded = () => {
-    // do nothing
-}, onRetry = () => {
-    // do nothing
-}, } = {}) {
+export function createServicePolicy({ maxRetries = DEFAULT_MAX_RETRIES, retryFilterPolicy = handleAll, maxConsecutiveFailures = DEFAULT_MAX_CONSECUTIVE_FAILURES, circuitBreakDuration = DEFAULT_CIRCUIT_BREAK_DURATION, degradedThreshold = DEFAULT_DEGRADED_THRESHOLD, } = {}) {
     const retryPolicy = retry(retryFilterPolicy, {
         // Note that although the option here is called "max attempts", it's really
         // maximum number of *retries* (attempts past the initial attempt).
@@ -105,6 +94,7 @@ export function createServicePolicy({ maxRetries = DEFAULT_MAX_RETRIES, retryFil
         // determined by a backoff formula.
         backoff: new ExponentialBackoff(),
     });
+    const onRetry = retryPolicy.onRetry.bind(retryPolicy);
     const circuitBreakerPolicy = circuitBreaker(handleAll, {
         // While the circuit is open, any additional invocations of the service
         // passed to the policy (either via automatic retries or by manually
@@ -115,37 +105,36 @@ export function createServicePolicy({ maxRetries = DEFAULT_MAX_RETRIES, retryFil
         halfOpenAfter: circuitBreakDuration,
         breaker: new ConsecutiveBreaker(maxConsecutiveFailures),
     });
-    // The `onBreak` callback will be called if the service consistently throws
-    // for as many times as exceeds the maximum consecutive number of failures.
-    // Combined with the retry policy, this can happen if:
-    // - `maxConsecutiveFailures` < the default max retries (3) and the policy is
-    // executed once
-    // - `maxConsecutiveFailures` >= the default max retries (3) but the policy is
-    //   executed multiple times, enough for the total number of retries to exceed
-    //   `maxConsecutiveFailures`
-    circuitBreakerPolicy.onBreak(onBreak);
-    // The `onRetryPolicy` callback will be called each time the service is
-    // invoked (including retries).
-    retryPolicy.onRetry(onRetry);
+    const onBreak = circuitBreakerPolicy.onBreak.bind(circuitBreakerPolicy);
+    const onDegradedListeners = [];
     retryPolicy.onGiveUp(() => {
         if (circuitBreakerPolicy.state === CircuitState.Closed) {
-            // The `onDegraded` callback will be called if the number of retries is
-            // exceeded and the maximum number of consecutive failures has not been
-            // reached yet (whether the policy is called once or multiple times).
-            onDegraded();
+            for (const listener of onDegradedListeners) {
+                listener();
+            }
         }
     });
     retryPolicy.onSuccess(({ duration }) => {
         if (circuitBreakerPolicy.state === CircuitState.Closed &&
             duration > degradedThreshold) {
-            // The `onDegraded` callback will also be called if the service does not
-            // throw, but the time it takes for the service to run exceeds the
-            // `degradedThreshold`.
-            onDegraded();
+            for (const listener of onDegradedListeners) {
+                listener();
+            }
         }
     });
-    // The retry policy really retries the circuit breaker policy, which invokes
-    // the service.
-    return wrap(retryPolicy, circuitBreakerPolicy);
+    const onDegraded = (listener) => {
+        onDegradedListeners.push(listener);
+    };
+    // Every time the retry policy makes an attempt, it executes the circuit
+    // breaker policy, which executes the service.
+    const policy = wrap(retryPolicy, circuitBreakerPolicy);
+    return {
+        ...policy,
+        circuitBreakerPolicy,
+        retryPolicy,
+        onBreak,
+        onDegraded,
+        onRetry,
+    };
 }
 //# sourceMappingURL=create-service-policy.mjs.map

package/dist/create-service-policy.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"create-service-policy.mjs","sourceRoot":"","sources":["../src/create-service-policy.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,kBAAkB,EAClB,kBAAkB,EAClB,SAAS,EACT,KAAK,EACL,IAAI,EACJ,YAAY,EACb,kBAAkB;AAKnB;;;GAGG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAC;AAErC;;;GAGG;AACH,MAAM,CAAC,MAAM,gCAAgC,GAAG,CAAC,CAAC,GAAG,mBAAmB,CAAC,GAAG,CAAC,CAAC;AAE9E;;;GAGG;AACH,MAAM,CAAC,MAAM,8BAA8B,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;AAE7D;;;GAGG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,IAAK,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsEG;AACH,MAAM,UAAU,mBAAmB,CAAC,EAClC,UAAU,GAAG,mBAAmB,EAChC,iBAAiB,GAAG,SAAS,EAC7B,sBAAsB,GAAG,gCAAgC,EACzD,oBAAoB,GAAG,8BAA8B,EACrD,iBAAiB,GAAG,0BAA0B,EAC9C,OAAO,GAAG,GAAG,EAAE;IACb,aAAa;AACf,CAAC,EACD,UAAU,GAAG,GAAG,EAAE;IAChB,aAAa;AACf,CAAC,EACD,OAAO,GAAG,GAAG,EAAE;IACb,aAAa;AACf,CAAC,MAUC,EAAE;IACJ,MAAM,WAAW,GAAG,KAAK,CAAC,iBAAiB,EAAE;QAC3C,2EAA2E;QAC3E,mEAAmE;QACnE,WAAW,EAAE,UAAU;QACvB,4EAA4E;QAC5E,mCAAmC;QACnC,OAAO,EAAE,IAAI,kBAAkB,EAAE;KAClC,CAAC,CAAC;IAEH,MAAM,oBAAoB,GAAG,cAAc,CAAC,SAAS,EAAE;QACrD,uEAAuE;QACvE,oEAAoE;QACpE,wEAAwE;QACxE,4EAA4E;QAC5E,qEAAqE;QACrE,qDAAqD;QACrD,aAAa,EAAE,oBAAoB;QACnC,OAAO,EAAE,IAAI,kBAAkB,CAAC,sBAAsB,CAAC;KACxD,CAAC,CAAC;IAEH,2EAA2E;IAC3E,2EAA2E;IAC3E,sDAAsD;IACtD,6EAA6E;IAC7E,gBAAgB;IAChB,8EAA8E;IAC9E,8EAA8E;IAC9E,6BAA6B;IAC7B,oBAAoB,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IAEtC,uEAAuE;IACvE,+BAA+B;IAC/B,WAAW,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IAE7B,WAAW,CAAC,QAAQ,CAAC,GAAG,EAAE;QACxB,IAAI,oBAAoB,CAAC,KAAK,KAAK,YAAY,CAAC,MAAM,EAAE;YACtD,uEAAuE;YACvE,uEAAuE;YACvE,qEAAqE;YACrE,UAAU,EAAE,CAAC;SACd;IACH,CAAC,CAAC,CAAC;IACH,WAAW,CAAC,SAAS,CAAC,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE;QACrC,IACE,oBAAoB,CAAC,KAAK,KAAK,YAAY,CAAC,MAAM;YAClD,QAAQ,GAAG,iBAAiB,EAC5B;YACA,wEAAwE;YACxE,kEAAkE;YAClE,uBAAuB;YACvB,UAAU,EAAE,CAAC;SACd;IACH,CAAC,CAAC,CAAC;IAEH,4EAA4E;IAC5E,eAAe;IACf,OAAO,IAAI,CAAC,WAAW,EAAE,oBAAoB,CAAC,CAAC;AACjD,CAAC","sourcesContent":["import {\n  circuitBreaker,\n  ConsecutiveBreaker,\n  ExponentialBackoff,\n  handleAll,\n  retry,\n  wrap,\n  CircuitState,\n} from 'cockatiel';\nimport type { IPolicy, Policy } from 'cockatiel';\n\nexport type { IPolicy as IServicePolicy };\n\n/**\n * The maximum number of times that a failing service should be re-run before\n * giving up.\n */\nexport const DEFAULT_MAX_RETRIES = 3;\n\n/**\n * The maximum number of times that the service is allowed to fail before\n * pausing further retries.\n */\nexport const DEFAULT_MAX_CONSECUTIVE_FAILURES = (1 + DEFAULT_MAX_RETRIES) * 3;\n\n/**\n * The default length of time (in milliseconds) to temporarily pause retries of\n * the service after enough consecutive failures.\n */\nexport const DEFAULT_CIRCUIT_BREAK_DURATION = 30 * 60 * 1000;\n\n/**\n * The default length of time (in milliseconds) that governs when the service is\n * regarded as degraded (affecting when `onDegraded` is called).\n */\nexport const DEFAULT_DEGRADED_THRESHOLD = 5_000;\n\n/**\n * Constructs an object exposing an `execute` method which, given a function —\n * hereafter called the \"service\" — will retry that service with ever increasing\n * delays until it succeeds. If the policy detects too many consecutive\n * failures, it will block further retries until a designated time period has\n * passed; this particular behavior is primarily designed for services that wrap\n * API calls so as not to make needless HTTP requests when the API is down and\n * to be able to recover when the API comes back up. In addition, hooks allow\n * for responding to certain events, one of which can be used to detect when an\n * HTTP request is performing slowly.\n *\n * Internally, this function makes use of the retry and circuit breaker policies\n * from the [Cockatiel](https://www.npmjs.com/package/cockatiel) library; see\n * there for more.\n *\n * @param options - The options to this function.\n * @param options.maxRetries - The maximum number of times that a failing\n * service should be re-invoked before giving up. Defaults to 3.\n * @param options.retryFilterPolicy - The policy used to control when the\n * service should be retried based on either the result of the servce or an\n * error that it throws. For instance, you could use this to retry only certain\n * errors. See `handleWhen` and friends from Cockatiel for more.\n * @param options.maxConsecutiveFailures - The maximum number of times that the\n * service is allowed to fail before pausing further retries. Defaults to 12.\n * @param options.circuitBreakDuration - The length of time (in milliseconds) to\n * pause retries of the action after the number of failures reaches\n * `maxConsecutiveFailures`.\n * @param options.degradedThreshold - The length of time (in milliseconds) that\n * governs when the service is regarded as degraded (affecting when `onDegraded`\n * is called). Defaults to 5 seconds.\n * @param options.onBreak - A function which is called when the service fails\n * too many times in a row (specifically, more than `maxConsecutiveFailures`).\n * @param options.onDegraded - A function which is called when the service\n * succeeds before `maxConsecutiveFailures` is reached, but takes more time than\n * the `degradedThreshold` to run.\n * @param options.onRetry - A function which will be called the moment the\n * policy kicks off a timer to re-run the function passed to the policy. This is\n * primarily useful in tests where we are mocking timers.\n * @returns The service policy.\n * @example\n * This function is designed to be used in the context of a service class like\n * this:\n * ``` ts\n * class Service {\n *   constructor() {\n *     this.#policy = createServicePolicy({\n *       maxRetries: 3,\n *       retryFilterPolicy: handleWhen((error) => {\n *         return error.message.includes('oops');\n *       }),\n *       maxConsecutiveFailures: 3,\n *       circuitBreakDuration: 5000,\n *       degradedThreshold: 2000,\n *       onBreak: () => {\n *         console.log('Circuit broke');\n *       },\n *       onDegraded: () => {\n *         console.log('Service is degraded');\n *       },\n *     });\n *   }\n *\n *   async fetch() {\n *     return await this.#policy.execute(async () => {\n *       const response = await fetch('https://some/url');\n *       return await response.json();\n *     });\n *   }\n * }\n * ```\n */\nexport function createServicePolicy({\n  maxRetries = DEFAULT_MAX_RETRIES,\n  retryFilterPolicy = handleAll,\n  maxConsecutiveFailures = DEFAULT_MAX_CONSECUTIVE_FAILURES,\n  circuitBreakDuration = DEFAULT_CIRCUIT_BREAK_DURATION,\n  degradedThreshold = DEFAULT_DEGRADED_THRESHOLD,\n  onBreak = () => {\n    // do nothing\n  },\n  onDegraded = () => {\n    // do nothing\n  },\n  onRetry = () => {\n    // do nothing\n  },\n}: {\n  maxRetries?: number;\n  retryFilterPolicy?: Policy;\n  maxConsecutiveFailures?: number;\n  circuitBreakDuration?: number;\n  degradedThreshold?: number;\n  onBreak?: () => void;\n  onDegraded?: () => void;\n  onRetry?: () => void;\n} = {}): IPolicy {\n  const retryPolicy = retry(retryFilterPolicy, {\n    // Note that although the option here is called \"max attempts\", it's really\n    // maximum number of *retries* (attempts past the initial attempt).\n    maxAttempts: maxRetries,\n    // Retries of the service will be executed following ever increasing delays,\n    // determined by a backoff formula.\n    backoff: new ExponentialBackoff(),\n  });\n\n  const circuitBreakerPolicy = circuitBreaker(handleAll, {\n    // While the circuit is open, any additional invocations of the service\n    // passed to the policy (either via automatic retries or by manually\n    // executing the policy again) will result in a BrokenCircuitError. This\n    // will remain the case until `circuitBreakDuration` passes, after which the\n    // service will be allowed to run again. If the service succeeds, the\n    // circuit will close, otherwise it will remain open.\n    halfOpenAfter: circuitBreakDuration,\n    breaker: new ConsecutiveBreaker(maxConsecutiveFailures),\n  });\n\n  // The `onBreak` callback will be called if the service consistently throws\n  // for as many times as exceeds the maximum consecutive number of failures.\n  // Combined with the retry policy, this can happen if:\n  // - `maxConsecutiveFailures` < the default max retries (3) and the policy is\n  // executed once\n  // - `maxConsecutiveFailures` >= the default max retries (3) but the policy is\n  //   executed multiple times, enough for the total number of retries to exceed\n  //   `maxConsecutiveFailures`\n  circuitBreakerPolicy.onBreak(onBreak);\n\n  // The `onRetryPolicy` callback will be called each time the service is\n  // invoked (including retries).\n  retryPolicy.onRetry(onRetry);\n\n  retryPolicy.onGiveUp(() => {\n    if (circuitBreakerPolicy.state === CircuitState.Closed) {\n      // The `onDegraded` callback will be called if the number of retries is\n      // exceeded and the maximum number of consecutive failures has not been\n      // reached yet (whether the policy is called once or multiple times).\n      onDegraded();\n    }\n  });\n  retryPolicy.onSuccess(({ duration }) => {\n    if (\n      circuitBreakerPolicy.state === CircuitState.Closed &&\n      duration > degradedThreshold\n    ) {\n      // The `onDegraded` callback will also be called if the service does not\n      // throw, but the time it takes for the service to run exceeds the\n      // `degradedThreshold`.\n      onDegraded();\n    }\n  });\n\n  // The retry policy really retries the circuit breaker policy, which invokes\n  // the service.\n  return wrap(retryPolicy, circuitBreakerPolicy);\n}\n"]}
+{"version":3,"file":"create-service-policy.mjs","sourceRoot":"","sources":["../src/create-service-policy.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,YAAY,EACZ,kBAAkB,EAClB,kBAAkB,EAClB,cAAc,EACd,SAAS,EACT,UAAU,EACV,KAAK,EACL,IAAI,EACL,kBAAkB;AAQnB,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,SAAS,EAAE,UAAU,EAAE,CAAC;AAqEnE;;;GAGG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAC;AAErC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,gCAAgC,GAAG,CAAC,CAAC,GAAG,mBAAmB,CAAC,GAAG,CAAC,CAAC;AAE9E;;;GAGG;AACH,MAAM,CAAC,MAAM,8BAA8B,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;AAE7D;;;GAGG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,IAAK,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,MAAM,UAAU,mBAAmB,CAAC,EAClC,UAAU,GAAG,mBAAmB,EAChC,iBAAiB,GAAG,SAAS,EAC7B,sBAAsB,GAAG,gCAAgC,EACzD,oBAAoB,GAAG,8BAA8B,EACrD,iBAAiB,GAAG,0BAA0B,MAChB,EAAE;IAChC,MAAM,WAAW,GAAG,KAAK,CAAC,iBAAiB,EAAE;QAC3C,2EAA2E;QAC3E,mEAAmE;QACnE,WAAW,EAAE,UAAU;QACvB,4EAA4E;QAC5E,mCAAmC;QACnC,OAAO,EAAE,IAAI,kBAAkB,EAAE;KAClC,CAAC,CAAC;IACH,MAAM,OAAO,GAAG,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAEtD,MAAM,oBAAoB,GAAG,cAAc,CAAC,SAAS,EAAE;QACrD,uEAAuE;QACvE,oEAAoE;QACpE,wEAAwE;QACxE,4EAA4E;QAC5E,qEAAqE;QACrE,qDAAqD;QACrD,aAAa,EAAE,oBAAoB;QACnC,OAAO,EAAE,IAAI,kBAAkB,CAAC,sBAAsB,CAAC;KACxD,CAAC,CAAC;IACH,MAAM,OAAO,GAAG,oBAAoB,CAAC,OAAO,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;IAExE,MAAM,mBAAmB,GAAmB,EAAE,CAAC;IAC/C,WAAW,CAAC,QAAQ,CAAC,GAAG,EAAE;QACxB,IAAI,oBAAoB,CAAC,KAAK,KAAK,YAAY,CAAC,MAAM,EAAE;YACtD,KAAK,MAAM,QAAQ,IAAI,mBAAmB,EAAE;gBAC1C,QAAQ,EAAE,CAAC;aACZ;SACF;IACH,CAAC,CAAC,CAAC;IACH,WAAW,CAAC,SAAS,CAAC,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE;QACrC,IACE,oBAAoB,CAAC,KAAK,KAAK,YAAY,CAAC,MAAM;YAClD,QAAQ,GAAG,iBAAiB,EAC5B;YACA,KAAK,MAAM,QAAQ,IAAI,mBAAmB,EAAE;gBAC1C,QAAQ,EAAE,CAAC;aACZ;SACF;IACH,CAAC,CAAC,CAAC;IACH,MAAM,UAAU,GAAG,CAAC,QAAoB,EAAE,EAAE;QAC1C,mBAAmB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IACrC,CAAC,CAAC;IAEF,wEAAwE;IACxE,8CAA8C;IAC9C,MAAM,MAAM,GAAG,IAAI,CAAC,WAAW,EAAE,oBAAoB,CAAC,CAAC;IAEvD,OAAO;QACL,GAAG,MAAM;QACT,oBAAoB;QACpB,WAAW;QACX,OAAO;QACP,UAAU;QACV,OAAO;KACR,CAAC;AACJ,CAAC","sourcesContent":["import {\n  BrokenCircuitError,\n  CircuitState,\n  ConsecutiveBreaker,\n  ExponentialBackoff,\n  circuitBreaker,\n  handleAll,\n  handleWhen,\n  retry,\n  wrap,\n} from 'cockatiel';\nimport type {\n  CircuitBreakerPolicy,\n  IPolicy,\n  Policy,\n  RetryPolicy,\n} from 'cockatiel';\n\nexport { CircuitState, BrokenCircuitError, handleAll, handleWhen };\n\n/**\n * The options for `createServicePolicy`.\n */\nexport type CreateServicePolicyOptions = {\n  /**\n   * The length of time (in milliseconds) to pause retries of the action after\n   * the number of failures reaches `maxConsecutiveFailures`.\n   */\n  circuitBreakDuration?: number;\n  /**\n   * The length of time (in milliseconds) that governs when the service is\n   * regarded as degraded (affecting when `onDegraded` is called).\n   */\n  degradedThreshold?: number;\n  /**\n   * The maximum number of times that the service is allowed to fail before\n   * pausing further retries.\n   */\n  maxConsecutiveFailures?: number;\n  /**\n   * The maximum number of times that a failing service should be re-invoked\n   * before giving up.\n   */\n  maxRetries?: number;\n  /**\n   * The policy used to control when the service should be retried based on\n   * either the result of the service or an error that it throws. For instance,\n   * you could use this to retry only certain errors. See `handleWhen` and\n   * friends from Cockatiel for more.\n   */\n  retryFilterPolicy?: Policy;\n};\n\n/**\n * The service policy object.\n */\nexport type ServicePolicy = IPolicy & {\n  /**\n   * The Cockatiel circuit breaker policy that the service policy uses\n   * internally.\n   */\n  circuitBreakerPolicy: CircuitBreakerPolicy;\n  /**\n   * The Cockatiel retry policy that the service policy uses internally.\n   */\n  retryPolicy: RetryPolicy;\n  /**\n   * A function which is called when the number of times that the service fails\n   * in a row meets the set maximum number of consecutive failures.\n   */\n  onBreak: CircuitBreakerPolicy['onBreak'];\n  /**\n   * A function which is called in two circumstances: 1) when the service\n   * succeeds before the maximum number of consecutive failures is reached, but\n   * takes more time than the `degradedThreshold` to run, or 2) if the service\n   * never succeeds before the retry policy gives up and before the maximum\n   * number of consecutive failures has been reached.\n   */\n  onDegraded: (fn: () => void) => void;\n  /**\n   * A function which will be called by the retry policy each time the service\n   * fails and the policy kicks off a timer to re-run the service. This is\n   * primarily useful in tests where we are mocking timers.\n   */\n  onRetry: RetryPolicy['onRetry'];\n};\n\n/**\n * The maximum number of times that a failing service should be re-run before\n * giving up.\n */\nexport const DEFAULT_MAX_RETRIES = 3;\n\n/**\n * The maximum number of times that the service is allowed to fail before\n * pausing further retries. This is set to a value such that if given a\n * service that continually fails, the policy needs to be executed 3 times\n * before further retries are paused.\n */\nexport const DEFAULT_MAX_CONSECUTIVE_FAILURES = (1 + DEFAULT_MAX_RETRIES) * 3;\n\n/**\n * The default length of time (in milliseconds) to temporarily pause retries of\n * the service after enough consecutive failures.\n */\nexport const DEFAULT_CIRCUIT_BREAK_DURATION = 30 * 60 * 1000;\n\n/**\n * The default length of time (in milliseconds) that governs when the service is\n * regarded as degraded (affecting when `onDegraded` is called).\n */\nexport const DEFAULT_DEGRADED_THRESHOLD = 5_000;\n\n/**\n * Constructs an object exposing an `execute` method which, given a function —\n * hereafter called the \"service\" — will retry that service with ever increasing\n * delays until it succeeds. If the policy detects too many consecutive\n * failures, it will block further retries until a designated time period has\n * passed; this particular behavior is primarily designed for services that wrap\n * API calls so as not to make needless HTTP requests when the API is down and\n * to be able to recover when the API comes back up. In addition, hooks allow\n * for responding to certain events, one of which can be used to detect when an\n * HTTP request is performing slowly.\n *\n * Internally, this function makes use of the retry and circuit breaker policies\n * from the [Cockatiel](https://www.npmjs.com/package/cockatiel) library; see\n * there for more.\n *\n * @param options - The options to this function.\n * @param options.maxRetries - The maximum number of times that a failing\n * service should be re-invoked before giving up. Defaults to 3.\n * @param options.retryFilterPolicy - The policy used to control when the\n * service should be retried based on either the result of the servce or an\n * error that it throws. For instance, you could use this to retry only certain\n * errors. See `handleWhen` and friends from Cockatiel for more.\n * @param options.maxConsecutiveFailures - The maximum number of times that the\n * service is allowed to fail before pausing further retries. Defaults to 12.\n * @param options.circuitBreakDuration - The length of time (in milliseconds) to\n * pause retries of the action after the number of failures reaches\n * `maxConsecutiveFailures`.\n * @param options.degradedThreshold - The length of time (in milliseconds) that\n * governs when the service is regarded as degraded (affecting when `onDegraded`\n * is called). Defaults to 5 seconds.\n * @returns The service policy.\n * @example\n * This function is designed to be used in the context of a service class like\n * this:\n * ``` ts\n * class Service {\n *   constructor() {\n *     this.#policy = createServicePolicy({\n *       maxRetries: 3,\n *       retryFilterPolicy: handleWhen((error) => {\n *         return error.message.includes('oops');\n *       }),\n *       maxConsecutiveFailures: 3,\n *       circuitBreakDuration: 5000,\n *       degradedThreshold: 2000,\n *       onBreak: () => {\n *         console.log('Circuit broke');\n *       },\n *       onDegraded: () => {\n *         console.log('Service is degraded');\n *       },\n *     });\n *   }\n *\n *   async fetch() {\n *     return await this.#policy.execute(async () => {\n *       const response = await fetch('https://some/url');\n *       return await response.json();\n *     });\n *   }\n * }\n * ```\n */\nexport function createServicePolicy({\n  maxRetries = DEFAULT_MAX_RETRIES,\n  retryFilterPolicy = handleAll,\n  maxConsecutiveFailures = DEFAULT_MAX_CONSECUTIVE_FAILURES,\n  circuitBreakDuration = DEFAULT_CIRCUIT_BREAK_DURATION,\n  degradedThreshold = DEFAULT_DEGRADED_THRESHOLD,\n}: CreateServicePolicyOptions = {}): ServicePolicy {\n  const retryPolicy = retry(retryFilterPolicy, {\n    // Note that although the option here is called \"max attempts\", it's really\n    // maximum number of *retries* (attempts past the initial attempt).\n    maxAttempts: maxRetries,\n    // Retries of the service will be executed following ever increasing delays,\n    // determined by a backoff formula.\n    backoff: new ExponentialBackoff(),\n  });\n  const onRetry = retryPolicy.onRetry.bind(retryPolicy);\n\n  const circuitBreakerPolicy = circuitBreaker(handleAll, {\n    // While the circuit is open, any additional invocations of the service\n    // passed to the policy (either via automatic retries or by manually\n    // executing the policy again) will result in a BrokenCircuitError. This\n    // will remain the case until `circuitBreakDuration` passes, after which the\n    // service will be allowed to run again. If the service succeeds, the\n    // circuit will close, otherwise it will remain open.\n    halfOpenAfter: circuitBreakDuration,\n    breaker: new ConsecutiveBreaker(maxConsecutiveFailures),\n  });\n  const onBreak = circuitBreakerPolicy.onBreak.bind(circuitBreakerPolicy);\n\n  const onDegradedListeners: (() => void)[] = [];\n  retryPolicy.onGiveUp(() => {\n    if (circuitBreakerPolicy.state === CircuitState.Closed) {\n      for (const listener of onDegradedListeners) {\n        listener();\n      }\n    }\n  });\n  retryPolicy.onSuccess(({ duration }) => {\n    if (\n      circuitBreakerPolicy.state === CircuitState.Closed &&\n      duration > degradedThreshold\n    ) {\n      for (const listener of onDegradedListeners) {\n        listener();\n      }\n    }\n  });\n  const onDegraded = (listener: () => void) => {\n    onDegradedListeners.push(listener);\n  };\n\n  // Every time the retry policy makes an attempt, it executes the circuit\n  // breaker policy, which executes the service.\n  const policy = wrap(retryPolicy, circuitBreakerPolicy);\n\n  return {\n    ...policy,\n    circuitBreakerPolicy,\n    retryPolicy,\n    onBreak,\n    onDegraded,\n    onRetry,\n  };\n}\n"]}

package/dist/index.cjs

@@ -14,13 +14,17 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isEqualCaseInsensitive = exports.weiHexToGweiDec = exports.toHex = exports.toChecksumHexAddress = exports.timeoutFetch = exports.successfulFetch = exports.safelyExecuteWithTimeout = exports.safelyExecute = exports.query = exports.normalizeEnsName = exports.isValidHexAddress = exports.isValidJson = exports.isSmartContractCode = exports.isSafeDynamicKey = exports.isSafeChainId = exports.isPlainObject = exports.isNonEmptyArray = exports.hexToText = exports.hexToBN = exports.handleFetch = exports.gweiDecToWEIBN = exports.getBuyURL = exports.fromHex = exports.fractionBN = exports.fetchWithErrorHandling = exports.convertHexToDecimal = exports.BNToHex = exports.createServicePolicy = exports.DEFAULT_MAX_RETRIES = exports.DEFAULT_MAX_CONSECUTIVE_FAILURES = exports.DEFAULT_DEGRADED_THRESHOLD = exports.DEFAULT_CIRCUIT_BREAK_DURATION = void 0;
+exports.isEqualCaseInsensitive = exports.weiHexToGweiDec = exports.toHex = exports.toChecksumHexAddress = exports.timeoutFetch = exports.successfulFetch = exports.safelyExecuteWithTimeout = exports.safelyExecute = exports.query = exports.normalizeEnsName = exports.isValidHexAddress = exports.isValidJson = exports.isSmartContractCode = exports.isSafeDynamicKey = exports.isSafeChainId = exports.isPlainObject = exports.isNonEmptyArray = exports.hexToText = exports.hexToBN = exports.handleFetch = exports.gweiDecToWEIBN = exports.getBuyURL = exports.fromHex = exports.fractionBN = exports.fetchWithErrorHandling = exports.convertHexToDecimal = exports.BNToHex = exports.handleWhen = exports.handleAll = exports.createServicePolicy = exports.DEFAULT_MAX_RETRIES = exports.DEFAULT_MAX_CONSECUTIVE_FAILURES = exports.DEFAULT_DEGRADED_THRESHOLD = exports.DEFAULT_CIRCUIT_BREAK_DURATION = exports.CircuitState = exports.BrokenCircuitError = void 0;
 var create_service_policy_1 = require("./create-service-policy.cjs");
+Object.defineProperty(exports, "BrokenCircuitError", { enumerable: true, get: function () { return create_service_policy_1.BrokenCircuitError; } });
+Object.defineProperty(exports, "CircuitState", { enumerable: true, get: function () { return create_service_policy_1.CircuitState; } });
 Object.defineProperty(exports, "DEFAULT_CIRCUIT_BREAK_DURATION", { enumerable: true, get: function () { return create_service_policy_1.DEFAULT_CIRCUIT_BREAK_DURATION; } });
 Object.defineProperty(exports, "DEFAULT_DEGRADED_THRESHOLD", { enumerable: true, get: function () { return create_service_policy_1.DEFAULT_DEGRADED_THRESHOLD; } });
 Object.defineProperty(exports, "DEFAULT_MAX_CONSECUTIVE_FAILURES", { enumerable: true, get: function () { return create_service_policy_1.DEFAULT_MAX_CONSECUTIVE_FAILURES; } });
 Object.defineProperty(exports, "DEFAULT_MAX_RETRIES", { enumerable: true, get: function () { return create_service_policy_1.DEFAULT_MAX_RETRIES; } });
 Object.defineProperty(exports, "createServicePolicy", { enumerable: true, get: function () { return create_service_policy_1.createServicePolicy; } });
+Object.defineProperty(exports, "handleAll", { enumerable: true, get: function () { return create_service_policy_1.handleAll; } });
+Object.defineProperty(exports, "handleWhen", { enumerable: true, get: function () { return create_service_policy_1.handleWhen; } });
 __exportStar(require("./constants.cjs"), exports);
 var util_1 = require("./util.cjs");
 Object.defineProperty(exports, "BNToHex", { enumerable: true, get: function () { return util_1.BNToHex; } });

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,qEAMiC;AAL/B,uIAAA,8BAA8B,OAAA;AAC9B,mIAAA,0BAA0B,OAAA;AAC1B,yIAAA,gCAAgC,OAAA;AAChC,4HAAA,mBAAmB,OAAA;AACnB,4HAAA,mBAAmB,OAAA;AAGrB,kDAA4B;AAE5B,mCA4BgB;AA3Bd,+FAAA,OAAO,OAAA;AACP,2GAAA,mBAAmB,OAAA;AACnB,8GAAA,sBAAsB,OAAA;AACtB,kGAAA,UAAU,OAAA;AACV,+FAAA,OAAO,OAAA;AACP,iGAAA,SAAS,OAAA;AACT,sGAAA,cAAc,OAAA;AACd,mGAAA,WAAW,OAAA;AACX,+FAAA,OAAO,OAAA;AACP,iGAAA,SAAS,OAAA;AACT,uGAAA,eAAe,OAAA;AACf,qGAAA,aAAa,OAAA;AACb,qGAAA,aAAa,OAAA;AACb,wGAAA,gBAAgB,OAAA;AAChB,2GAAA,mBAAmB,OAAA;AACnB,mGAAA,WAAW,OAAA;AACX,yGAAA,iBAAiB,OAAA;AACjB,wGAAA,gBAAgB,OAAA;AAChB,6FAAA,KAAK,OAAA;AACL,qGAAA,aAAa,OAAA;AACb,gHAAA,wBAAwB,OAAA;AACxB,uGAAA,eAAe,OAAA;AACf,oGAAA,YAAY,OAAA;AACZ,4GAAA,oBAAoB,OAAA;AACpB,6FAAA,KAAK,OAAA;AACL,uGAAA,eAAe,OAAA;AACf,8GAAA,sBAAsB,OAAA;AAExB,8CAAwB;AACxB,6CAAuB","sourcesContent":["export {\n  DEFAULT_CIRCUIT_BREAK_DURATION,\n  DEFAULT_DEGRADED_THRESHOLD,\n  DEFAULT_MAX_CONSECUTIVE_FAILURES,\n  DEFAULT_MAX_RETRIES,\n  createServicePolicy,\n} from './create-service-policy';\nexport type { IServicePolicy } from './create-service-policy';\nexport * from './constants';\nexport type { NonEmptyArray } from './util';\nexport {\n  BNToHex,\n  convertHexToDecimal,\n  fetchWithErrorHandling,\n  fractionBN,\n  fromHex,\n  getBuyURL,\n  gweiDecToWEIBN,\n  handleFetch,\n  hexToBN,\n  hexToText,\n  isNonEmptyArray,\n  isPlainObject,\n  isSafeChainId,\n  isSafeDynamicKey,\n  isSmartContractCode,\n  isValidJson,\n  isValidHexAddress,\n  normalizeEnsName,\n  query,\n  safelyExecute,\n  safelyExecuteWithTimeout,\n  successfulFetch,\n  timeoutFetch,\n  toChecksumHexAddress,\n  toHex,\n  weiHexToGweiDec,\n  isEqualCaseInsensitive,\n} from './util';\nexport * from './types';\nexport * from './siwe';\n"]}
+{"version":3,"file":"index.cjs","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,qEAUiC;AAT/B,2HAAA,kBAAkB,OAAA;AAClB,qHAAA,YAAY,OAAA;AACZ,uIAAA,8BAA8B,OAAA;AAC9B,mIAAA,0BAA0B,OAAA;AAC1B,yIAAA,gCAAgC,OAAA;AAChC,4HAAA,mBAAmB,OAAA;AACnB,4HAAA,mBAAmB,OAAA;AACnB,kHAAA,SAAS,OAAA;AACT,mHAAA,UAAU,OAAA;AAMZ,kDAA4B;AAE5B,mCA4BgB;AA3Bd,+FAAA,OAAO,OAAA;AACP,2GAAA,mBAAmB,OAAA;AACnB,8GAAA,sBAAsB,OAAA;AACtB,kGAAA,UAAU,OAAA;AACV,+FAAA,OAAO,OAAA;AACP,iGAAA,SAAS,OAAA;AACT,sGAAA,cAAc,OAAA;AACd,mGAAA,WAAW,OAAA;AACX,+FAAA,OAAO,OAAA;AACP,iGAAA,SAAS,OAAA;AACT,uGAAA,eAAe,OAAA;AACf,qGAAA,aAAa,OAAA;AACb,qGAAA,aAAa,OAAA;AACb,wGAAA,gBAAgB,OAAA;AAChB,2GAAA,mBAAmB,OAAA;AACnB,mGAAA,WAAW,OAAA;AACX,yGAAA,iBAAiB,OAAA;AACjB,wGAAA,gBAAgB,OAAA;AAChB,6FAAA,KAAK,OAAA;AACL,qGAAA,aAAa,OAAA;AACb,gHAAA,wBAAwB,OAAA;AACxB,uGAAA,eAAe,OAAA;AACf,oGAAA,YAAY,OAAA;AACZ,4GAAA,oBAAoB,OAAA;AACpB,6FAAA,KAAK,OAAA;AACL,uGAAA,eAAe,OAAA;AACf,8GAAA,sBAAsB,OAAA;AAExB,8CAAwB;AACxB,6CAAuB","sourcesContent":["export {\n  BrokenCircuitError,\n  CircuitState,\n  DEFAULT_CIRCUIT_BREAK_DURATION,\n  DEFAULT_DEGRADED_THRESHOLD,\n  DEFAULT_MAX_CONSECUTIVE_FAILURES,\n  DEFAULT_MAX_RETRIES,\n  createServicePolicy,\n  handleAll,\n  handleWhen,\n} from './create-service-policy';\nexport type {\n  CreateServicePolicyOptions,\n  ServicePolicy,\n} from './create-service-policy';\nexport * from './constants';\nexport type { NonEmptyArray } from './util';\nexport {\n  BNToHex,\n  convertHexToDecimal,\n  fetchWithErrorHandling,\n  fractionBN,\n  fromHex,\n  getBuyURL,\n  gweiDecToWEIBN,\n  handleFetch,\n  hexToBN,\n  hexToText,\n  isNonEmptyArray,\n  isPlainObject,\n  isSafeChainId,\n  isSafeDynamicKey,\n  isSmartContractCode,\n  isValidJson,\n  isValidHexAddress,\n  normalizeEnsName,\n  query,\n  safelyExecute,\n  safelyExecuteWithTimeout,\n  successfulFetch,\n  timeoutFetch,\n  toChecksumHexAddress,\n  toHex,\n  weiHexToGweiDec,\n  isEqualCaseInsensitive,\n} from './util';\nexport * from './types';\nexport * from './siwe';\n"]}

package/dist/index.d.cts

@@ -1,5 +1,5 @@
-export { DEFAULT_CIRCUIT_BREAK_DURATION, DEFAULT_DEGRADED_THRESHOLD, DEFAULT_MAX_CONSECUTIVE_FAILURES, DEFAULT_MAX_RETRIES, createServicePolicy, } from "./create-service-policy.cjs";
-export type { IServicePolicy } from "./create-service-policy.cjs";
+export { BrokenCircuitError, CircuitState, DEFAULT_CIRCUIT_BREAK_DURATION, DEFAULT_DEGRADED_THRESHOLD, DEFAULT_MAX_CONSECUTIVE_FAILURES, DEFAULT_MAX_RETRIES, createServicePolicy, handleAll, handleWhen, } from "./create-service-policy.cjs";
+export type { CreateServicePolicyOptions, ServicePolicy, } from "./create-service-policy.cjs";
 export * from "./constants.cjs";
 export type { NonEmptyArray } from "./util.cjs";
 export { BNToHex, convertHexToDecimal, fetchWithErrorHandling, fractionBN, fromHex, getBuyURL, gweiDecToWEIBN, handleFetch, hexToBN, hexToText, isNonEmptyArray, isPlainObject, isSafeChainId, isSafeDynamicKey, isSmartContractCode, isValidJson, isValidHexAddress, normalizeEnsName, query, safelyExecute, safelyExecuteWithTimeout, successfulFetch, timeoutFetch, toChecksumHexAddress, toHex, weiHexToGweiDec, isEqualCaseInsensitive, } from "./util.cjs";

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,8BAA8B,EAC9B,0BAA0B,EAC1B,gCAAgC,EAChC,mBAAmB,EACnB,mBAAmB,GACpB,oCAAgC;AACjC,YAAY,EAAE,cAAc,EAAE,oCAAgC;AAC9D,gCAA4B;AAC5B,YAAY,EAAE,aAAa,EAAE,mBAAe;AAC5C,OAAO,EACL,OAAO,EACP,mBAAmB,EACnB,sBAAsB,EACtB,UAAU,EACV,OAAO,EACP,SAAS,EACT,cAAc,EACd,WAAW,EACX,OAAO,EACP,SAAS,EACT,eAAe,EACf,aAAa,EACb,aAAa,EACb,gBAAgB,EAChB,mBAAmB,EACnB,WAAW,EACX,iBAAiB,EACjB,gBAAgB,EAChB,KAAK,EACL,aAAa,EACb,wBAAwB,EACxB,eAAe,EACf,YAAY,EACZ,oBAAoB,EACpB,KAAK,EACL,eAAe,EACf,sBAAsB,GACvB,mBAAe;AAChB,4BAAwB;AACxB,2BAAuB"}
+{"version":3,"file":"index.d.cts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,YAAY,EACZ,8BAA8B,EAC9B,0BAA0B,EAC1B,gCAAgC,EAChC,mBAAmB,EACnB,mBAAmB,EACnB,SAAS,EACT,UAAU,GACX,oCAAgC;AACjC,YAAY,EACV,0BAA0B,EAC1B,aAAa,GACd,oCAAgC;AACjC,gCAA4B;AAC5B,YAAY,EAAE,aAAa,EAAE,mBAAe;AAC5C,OAAO,EACL,OAAO,EACP,mBAAmB,EACnB,sBAAsB,EACtB,UAAU,EACV,OAAO,EACP,SAAS,EACT,cAAc,EACd,WAAW,EACX,OAAO,EACP,SAAS,EACT,eAAe,EACf,aAAa,EACb,aAAa,EACb,gBAAgB,EAChB,mBAAmB,EACnB,WAAW,EACX,iBAAiB,EACjB,gBAAgB,EAChB,KAAK,EACL,aAAa,EACb,wBAAwB,EACxB,eAAe,EACf,YAAY,EACZ,oBAAoB,EACpB,KAAK,EACL,eAAe,EACf,sBAAsB,GACvB,mBAAe;AAChB,4BAAwB;AACxB,2BAAuB"}

package/dist/index.d.mts

@@ -1,5 +1,5 @@
-export { DEFAULT_CIRCUIT_BREAK_DURATION, DEFAULT_DEGRADED_THRESHOLD, DEFAULT_MAX_CONSECUTIVE_FAILURES, DEFAULT_MAX_RETRIES, createServicePolicy, } from "./create-service-policy.mjs";
-export type { IServicePolicy } from "./create-service-policy.mjs";
+export { BrokenCircuitError, CircuitState, DEFAULT_CIRCUIT_BREAK_DURATION, DEFAULT_DEGRADED_THRESHOLD, DEFAULT_MAX_CONSECUTIVE_FAILURES, DEFAULT_MAX_RETRIES, createServicePolicy, handleAll, handleWhen, } from "./create-service-policy.mjs";
+export type { CreateServicePolicyOptions, ServicePolicy, } from "./create-service-policy.mjs";
 export * from "./constants.mjs";
 export type { NonEmptyArray } from "./util.mjs";
 export { BNToHex, convertHexToDecimal, fetchWithErrorHandling, fractionBN, fromHex, getBuyURL, gweiDecToWEIBN, handleFetch, hexToBN, hexToText, isNonEmptyArray, isPlainObject, isSafeChainId, isSafeDynamicKey, isSmartContractCode, isValidJson, isValidHexAddress, normalizeEnsName, query, safelyExecute, safelyExecuteWithTimeout, successfulFetch, timeoutFetch, toChecksumHexAddress, toHex, weiHexToGweiDec, isEqualCaseInsensitive, } from "./util.mjs";

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,8BAA8B,EAC9B,0BAA0B,EAC1B,gCAAgC,EAChC,mBAAmB,EACnB,mBAAmB,GACpB,oCAAgC;AACjC,YAAY,EAAE,cAAc,EAAE,oCAAgC;AAC9D,gCAA4B;AAC5B,YAAY,EAAE,aAAa,EAAE,mBAAe;AAC5C,OAAO,EACL,OAAO,EACP,mBAAmB,EACnB,sBAAsB,EACtB,UAAU,EACV,OAAO,EACP,SAAS,EACT,cAAc,EACd,WAAW,EACX,OAAO,EACP,SAAS,EACT,eAAe,EACf,aAAa,EACb,aAAa,EACb,gBAAgB,EAChB,mBAAmB,EACnB,WAAW,EACX,iBAAiB,EACjB,gBAAgB,EAChB,KAAK,EACL,aAAa,EACb,wBAAwB,EACxB,eAAe,EACf,YAAY,EACZ,oBAAoB,EACpB,KAAK,EACL,eAAe,EACf,sBAAsB,GACvB,mBAAe;AAChB,4BAAwB;AACxB,2BAAuB"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,YAAY,EACZ,8BAA8B,EAC9B,0BAA0B,EAC1B,gCAAgC,EAChC,mBAAmB,EACnB,mBAAmB,EACnB,SAAS,EACT,UAAU,GACX,oCAAgC;AACjC,YAAY,EACV,0BAA0B,EAC1B,aAAa,GACd,oCAAgC;AACjC,gCAA4B;AAC5B,YAAY,EAAE,aAAa,EAAE,mBAAe;AAC5C,OAAO,EACL,OAAO,EACP,mBAAmB,EACnB,sBAAsB,EACtB,UAAU,EACV,OAAO,EACP,SAAS,EACT,cAAc,EACd,WAAW,EACX,OAAO,EACP,SAAS,EACT,eAAe,EACf,aAAa,EACb,aAAa,EACb,gBAAgB,EAChB,mBAAmB,EACnB,WAAW,EACX,iBAAiB,EACjB,gBAAgB,EAChB,KAAK,EACL,aAAa,EACb,wBAAwB,EACxB,eAAe,EACf,YAAY,EACZ,oBAAoB,EACpB,KAAK,EACL,eAAe,EACf,sBAAsB,GACvB,mBAAe;AAChB,4BAAwB;AACxB,2BAAuB"}

package/dist/index.mjs

@@ -1,4 +1,4 @@
-export { DEFAULT_CIRCUIT_BREAK_DURATION, DEFAULT_DEGRADED_THRESHOLD, DEFAULT_MAX_CONSECUTIVE_FAILURES, DEFAULT_MAX_RETRIES, createServicePolicy } from "./create-service-policy.mjs";
+export { BrokenCircuitError, CircuitState, DEFAULT_CIRCUIT_BREAK_DURATION, DEFAULT_DEGRADED_THRESHOLD, DEFAULT_MAX_CONSECUTIVE_FAILURES, DEFAULT_MAX_RETRIES, createServicePolicy, handleAll, handleWhen } from "./create-service-policy.mjs";
 export * from "./constants.mjs";
 export { BNToHex, convertHexToDecimal, fetchWithErrorHandling, fractionBN, fromHex, getBuyURL, gweiDecToWEIBN, handleFetch, hexToBN, hexToText, isNonEmptyArray, isPlainObject, isSafeChainId, isSafeDynamicKey, isSmartContractCode, isValidJson, isValidHexAddress, normalizeEnsName, query, safelyExecute, safelyExecuteWithTimeout, successfulFetch, timeoutFetch, toChecksumHexAddress, toHex, weiHexToGweiDec, isEqualCaseInsensitive } from "./util.mjs";
 export * from "./types.mjs";

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,8BAA8B,EAC9B,0BAA0B,EAC1B,gCAAgC,EAChC,mBAAmB,EACnB,mBAAmB,EACpB,oCAAgC;AAEjC,gCAA4B;AAE5B,OAAO,EACL,OAAO,EACP,mBAAmB,EACnB,sBAAsB,EACtB,UAAU,EACV,OAAO,EACP,SAAS,EACT,cAAc,EACd,WAAW,EACX,OAAO,EACP,SAAS,EACT,eAAe,EACf,aAAa,EACb,aAAa,EACb,gBAAgB,EAChB,mBAAmB,EACnB,WAAW,EACX,iBAAiB,EACjB,gBAAgB,EAChB,KAAK,EACL,aAAa,EACb,wBAAwB,EACxB,eAAe,EACf,YAAY,EACZ,oBAAoB,EACpB,KAAK,EACL,eAAe,EACf,sBAAsB,EACvB,mBAAe;AAChB,4BAAwB;AACxB,2BAAuB","sourcesContent":["export {\n  DEFAULT_CIRCUIT_BREAK_DURATION,\n  DEFAULT_DEGRADED_THRESHOLD,\n  DEFAULT_MAX_CONSECUTIVE_FAILURES,\n  DEFAULT_MAX_RETRIES,\n  createServicePolicy,\n} from './create-service-policy';\nexport type { IServicePolicy } from './create-service-policy';\nexport * from './constants';\nexport type { NonEmptyArray } from './util';\nexport {\n  BNToHex,\n  convertHexToDecimal,\n  fetchWithErrorHandling,\n  fractionBN,\n  fromHex,\n  getBuyURL,\n  gweiDecToWEIBN,\n  handleFetch,\n  hexToBN,\n  hexToText,\n  isNonEmptyArray,\n  isPlainObject,\n  isSafeChainId,\n  isSafeDynamicKey,\n  isSmartContractCode,\n  isValidJson,\n  isValidHexAddress,\n  normalizeEnsName,\n  query,\n  safelyExecute,\n  safelyExecuteWithTimeout,\n  successfulFetch,\n  timeoutFetch,\n  toChecksumHexAddress,\n  toHex,\n  weiHexToGweiDec,\n  isEqualCaseInsensitive,\n} from './util';\nexport * from './types';\nexport * from './siwe';\n"]}
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,YAAY,EACZ,8BAA8B,EAC9B,0BAA0B,EAC1B,gCAAgC,EAChC,mBAAmB,EACnB,mBAAmB,EACnB,SAAS,EACT,UAAU,EACX,oCAAgC;AAKjC,gCAA4B;AAE5B,OAAO,EACL,OAAO,EACP,mBAAmB,EACnB,sBAAsB,EACtB,UAAU,EACV,OAAO,EACP,SAAS,EACT,cAAc,EACd,WAAW,EACX,OAAO,EACP,SAAS,EACT,eAAe,EACf,aAAa,EACb,aAAa,EACb,gBAAgB,EAChB,mBAAmB,EACnB,WAAW,EACX,iBAAiB,EACjB,gBAAgB,EAChB,KAAK,EACL,aAAa,EACb,wBAAwB,EACxB,eAAe,EACf,YAAY,EACZ,oBAAoB,EACpB,KAAK,EACL,eAAe,EACf,sBAAsB,EACvB,mBAAe;AAChB,4BAAwB;AACxB,2BAAuB","sourcesContent":["export {\n  BrokenCircuitError,\n  CircuitState,\n  DEFAULT_CIRCUIT_BREAK_DURATION,\n  DEFAULT_DEGRADED_THRESHOLD,\n  DEFAULT_MAX_CONSECUTIVE_FAILURES,\n  DEFAULT_MAX_RETRIES,\n  createServicePolicy,\n  handleAll,\n  handleWhen,\n} from './create-service-policy';\nexport type {\n  CreateServicePolicyOptions,\n  ServicePolicy,\n} from './create-service-policy';\nexport * from './constants';\nexport type { NonEmptyArray } from './util';\nexport {\n  BNToHex,\n  convertHexToDecimal,\n  fetchWithErrorHandling,\n  fractionBN,\n  fromHex,\n  getBuyURL,\n  gweiDecToWEIBN,\n  handleFetch,\n  hexToBN,\n  hexToText,\n  isNonEmptyArray,\n  isPlainObject,\n  isSafeChainId,\n  isSafeDynamicKey,\n  isSmartContractCode,\n  isValidJson,\n  isValidHexAddress,\n  normalizeEnsName,\n  query,\n  safelyExecute,\n  safelyExecuteWithTimeout,\n  successfulFetch,\n  timeoutFetch,\n  toChecksumHexAddress,\n  toHex,\n  weiHexToGweiDec,\n  isEqualCaseInsensitive,\n} from './util';\nexport * from './types';\nexport * from './siwe';\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@metamask-previews/controller-utils",
-  "version": "11.4.5-preview-b1518d1",
+  "version": "11.4.5-preview-f3d5e317",
   "description": "Data and convenience functions shared by multiple packages",
   "keywords": [
     "MetaMask",