@internetarchive/fetch-handler 1.1.0-webdev-7731.8 → 1.1.0-webdev-7731.9

package/src/fetch-handler.ts

@@ -12,20 +12,32 @@ import type { RetryConfiguring } from './fetch-retry/configuration/retry-configu
  * - add `reCache=1` to the request if it's in the current url so the backend sees it
  * - add convenience method for fetching/decoding an API response by just the path
  */
-export class IaFetchHandler implements FetchHandlerInterface {
-  private iaApiBaseUrl?: string;
+export class FetchHandler implements FetchHandlerInterface {
+  private apiBaseUrl: string = '';
 
   private fetchRetrier: FetchRetrierInterface = new FetchRetrier();
 
   private searchParams?: string;
 
+  /**
+   *
+   * @param options {
+   *  iaApiBaseUrl - deprecated Use `apiBaseUrl` instead.
+   *  apiBaseUrl - The base URL for API requests for `fetchApiPathResponse`
+   *  fetchRetrier - FetchRetrier to use instead of the default
+   *  searchParams - Search params to check for `reCache=1` (defaults to current window location)
+   */
   constructor(options?: {
     iaApiBaseUrl?: string;
+    apiBaseUrl?: string;
     fetchRetrier?: FetchRetrierInterface;
     searchParams?: string;
-    defaultRetryConfiguration?: RetryConfiguring;
   }) {
-    if (options?.iaApiBaseUrl) this.iaApiBaseUrl = options.iaApiBaseUrl;
+    if (options?.apiBaseUrl) {
+      this.apiBaseUrl = options.apiBaseUrl;
+    } else if (options?.iaApiBaseUrl) {
+      this.apiBaseUrl = options.iaApiBaseUrl;
+    }
     if (options?.fetchRetrier) this.fetchRetrier = options.fetchRetrier;
     if (options?.searchParams) {
       this.searchParams = options.searchParams;
@@ -35,7 +47,7 @@ export class IaFetchHandler implements FetchHandlerInterface {
   }
 
   /** @inheritdoc */
-  async fetchIAApiResponse<T>(
+  async fetchApiPathResponse<T>(
     path: string,
     options?: {
       includeCredentials?: boolean;
@@ -45,10 +57,24 @@ export class IaFetchHandler implements FetchHandlerInterface {
       retryConfig?: RetryConfiguring;
     },
   ): Promise<T> {
-    const url = `${this.iaApiBaseUrl}${path}`;
+    const url = `${this.apiBaseUrl}${path}`;
     return this.fetchApiResponse(url, options);
   }
 
+  /** @inheritdoc */
+  async fetchIAApiResponse<T>(
+    path: string,
+    options?: {
+      includeCredentials?: boolean;
+      method?: string;
+      body?: BodyInit;
+      headers?: HeadersInit;
+      retryConfig?: RetryConfiguring;
+    },
+  ): Promise<T> {
+    return this.fetchApiPathResponse(path, options);
+  }
+
   /** @inheritdoc */
   async fetchApiResponse<T>(
     url: string,
@@ -104,3 +130,10 @@ export class IaFetchHandler implements FetchHandlerInterface {
     return url.href;
   }
 }
+
+/**
+ * Backwards compatibility class
+ *
+ * @deprecated Use `FetchHandler` instead.
+ */
+export class IaFetchHandler extends FetchHandler {}

package/src/fetch-retry/configuration/configurations.ts

@@ -2,10 +2,31 @@ import { DefaultRetryConfiguration } from './default-retry-configuration';
 import { NoRetryConfiguration } from './no-retry-configuration';
 import type { RetryConfiguring } from './retry-configuring';
 
+/**
+ * This class provides easy access to common retry configurations.
+ *
+ * ie `FetchRetryConfig.default` or `FetchRetryConfig.noRetry` vs
+ * `new DefaultRetryConfiguration()` or `new NoRetryConfiguration()`
+ */
 export class FetchRetryConfig {
+  /**
+   * A retry configuration that retries twice for transient errors
+   * with exponential retry delay as well as `Retry-After` header support.
+   *
+   * @static
+   * @type {Readonly<RetryConfiguring>}
+   * @memberof FetchRetryConfig
+   */
   static readonly default: Readonly<RetryConfiguring> =
     DefaultRetryConfiguration.shared;
 
+  /**
+   * A retry configuration that does not perform any retries.
+   *
+   * @static
+   * @type {Readonly<RetryConfiguring>}
+   * @memberof FetchRetryConfig
+   */
   static readonly noRetry: Readonly<RetryConfiguring> =
     NoRetryConfiguration.shared;
 }

package/src/fetch-retry/configuration/default-retry-configuration.ts

@@ -1,6 +1,10 @@
 import type { RetryConfiguring } from './retry-configuring';
 import type { Milliseconds } from './milliseconds';
 
+/**
+ * A retry configuration that retries twice for transient errors
+ * with exponential retry delay as well as `Retry-After` header support.
+ */
 export class DefaultRetryConfiguration implements RetryConfiguring {
   static readonly shared: Readonly<RetryConfiguring> =
     new DefaultRetryConfiguration();
@@ -36,7 +40,10 @@ export class DefaultRetryConfiguration implements RetryConfiguring {
     return isTransient;
   }
 
-  retryDelay(retryNumber: number, response?: Response | null): Milliseconds {
+  retryDelay(
+    retryNumber: number,
+    response?: Response | null,
+  ): Milliseconds | null {
     // If we have a Retry-After header, use that
     const retryAfter = response?.headers.get('Retry-After');
     if (retryAfter) {

package/src/fetch-retry/configuration/no-retry-configuration.ts

@@ -1,6 +1,9 @@
 import type { RetryConfiguring } from './retry-configuring';
 import type { Milliseconds } from './milliseconds';
 
+/**
+ * A retry configuration that does not perform any retries.
+ */
 export class NoRetryConfiguration implements RetryConfiguring {
   static readonly shared: Readonly<RetryConfiguring> =
     new NoRetryConfiguration();
@@ -9,7 +12,7 @@ export class NoRetryConfiguration implements RetryConfiguring {
     return false;
   }
 
-  retryDelay(): Milliseconds {
-    return 0;
+  retryDelay(): Milliseconds | null {
+    return null;
   }
 }

package/src/fetch-retry/configuration/retry-configuring.ts

@@ -7,5 +7,8 @@ export interface RetryConfiguring {
     error?: unknown,
   ): boolean;
 
-  retryDelay(retryNumber: number, response?: Response | null): Milliseconds;
+  retryDelay(
+    retryNumber: number,
+    response?: Response | null,
+  ): Milliseconds | null;
 }

package/src/fetch-retry/fetch-retrier.ts

@@ -4,6 +4,7 @@ import { type FetchOptions } from '../fetch-options';
 import { legacyArgsAsFetchOptions } from './legacy-args';
 import { DefaultRetryConfiguration } from './configuration/default-retry-configuration';
 import type { RetryConfiguring } from './configuration/retry-configuring';
+import { FetchRetryConfig } from './configuration/configurations';
 
 /**
  * A class that retries a fetch request.
@@ -26,17 +27,15 @@ export interface FetchRetrierInterface {
 export class FetchRetrier implements FetchRetrierInterface {
   private analyticsHandler?: AnalyticsHandlerInterface;
 
-  private retryConfiguration: RetryConfiguring =
-    new DefaultRetryConfiguration();
+  private retryConfig: RetryConfiguring = FetchRetryConfig.default;
 
   constructor(options?: {
     analyticsHandler?: AnalyticsHandlerInterface;
-    retryConfiguration?: RetryConfiguring;
+    retryConfig?: RetryConfiguring;
   }) {
     if (options?.analyticsHandler)
       this.analyticsHandler = options.analyticsHandler;
-    if (options?.retryConfiguration)
-      this.retryConfiguration = options.retryConfiguration;
+    if (options?.retryConfig) this.retryConfig = options.retryConfig;
   }
 
   /** @inheritdoc */
@@ -45,10 +44,10 @@ export class FetchRetrier implements FetchRetrierInterface {
     options?: RequestInit | FetchOptions,
   ): Promise<Response> {
     const fetchOptions = legacyArgsAsFetchOptions(options);
-    return await this.fetchRetryWithOptions(request, 0, fetchOptions);
+    return await this.doFetchRetry(request, 0, fetchOptions);
   }
 
-  private async fetchRetryWithOptions(
+  private async doFetchRetry(
     request: RequestInfo,
     retryNumber: number,
     options?: FetchOptions,
@@ -63,17 +62,20 @@ export class FetchRetrier implements FetchRetrierInterface {
         this.log4xx5xxResponse(response);
       }
 
-      const retryConfig = options?.retryConfig ?? this.retryConfiguration;
-      if (retryConfig.shouldRetry(response, retryNumber)) {
-        const delay = retryConfig.retryDelay(retryNumber, response);
-        await promisedSleep(delay);
-        this.logRetryEvent(
-          urlString,
-          retryNumber,
-          response.statusText,
-          response.status,
-        );
-        return this.fetchRetryWithOptions(request, retryNumber + 1, options);
+      const retryConfig = options?.retryConfig ?? this.retryConfig;
+      const shouldRetry = retryConfig.shouldRetry(response, retryNumber);
+      if (shouldRetry) {
+        const retryDelay = retryConfig.retryDelay(retryNumber, response);
+        if (retryDelay !== null) {
+          await promisedSleep(retryDelay);
+          this.logRetryEvent(
+            urlString,
+            retryNumber,
+            response.statusText,
+            response.status,
+          );
+          return this.doFetchRetry(request, retryNumber + 1, options);
+        }
       }
       this.logFailureEvent(urlString, response.status);
       return response;
@@ -84,12 +86,15 @@ export class FetchRetrier implements FetchRetrierInterface {
         throw error;
       }
 
-      const retryConfig = options?.retryConfig ?? this.retryConfiguration;
-      if (retryConfig.shouldRetry(null, retryNumber)) {
-        const delay = retryConfig.retryDelay(retryNumber);
-        await promisedSleep(delay);
-        this.logRetryEvent(urlString, retryNumber, error, error);
-        return this.fetchRetryWithOptions(request, retryNumber + 1, options);
+      const retryConfig = options?.retryConfig ?? this.retryConfig;
+      const shouldRetry = retryConfig.shouldRetry(null, retryNumber);
+      if (shouldRetry) {
+        const retryDelay = retryConfig.retryDelay(retryNumber);
+        if (retryDelay !== null) {
+          await promisedSleep(retryDelay);
+          this.logRetryEvent(urlString, retryNumber, error, error);
+          return this.doFetchRetry(request, retryNumber + 1, options);
+        }
       }
       this.logFailureEvent(urlString, error);
       throw error;

package/test/fetch-handler.test.ts

@@ -1,13 +1,46 @@
 import { expect } from '@open-wc/testing';
-import { IaFetchHandler } from '../src/fetch-handler';
+import { FetchHandler } from '../src/fetch-handler';
 import { MockFetchRetrier } from './mocks/mock-fetch-retrier';
 import { NoRetryConfiguration } from '../src/fetch-retry/configuration/no-retry-configuration';
 
 describe('Fetch Handler', () => {
+  describe('constructor', () => {
+    it('has no default apiBaseUrl', () => {
+      const fetchHandler = new FetchHandler();
+      // @ts-expect-error Accessing private property for test
+      expect(fetchHandler.apiBaseUrl).to.equal('');
+    });
+
+    it('sets iaApiBaseUrl if provided', () => {
+      const fetchHandler = new FetchHandler({
+        iaApiBaseUrl: 'https://example.org',
+      });
+      // @ts-expect-error Accessing private property for test
+      expect(fetchHandler.apiBaseUrl).to.equal('https://example.org');
+    });
+
+    it('sets apiBaseUrl if provided', () => {
+      const fetchHandler = new FetchHandler({
+        apiBaseUrl: 'https://api.example.org',
+      });
+      // @ts-expect-error Accessing private property for test
+      expect(fetchHandler.apiBaseUrl).to.equal('https://api.example.org');
+    });
+
+    it('uses apiBaseUrl over iaApiBaseUrl if both provided', () => {
+      const fetchHandler = new FetchHandler({
+        iaApiBaseUrl: 'https://example.org',
+        apiBaseUrl: 'https://api.example.org',
+      });
+      // @ts-expect-error Accessing private property for test
+      expect(fetchHandler.apiBaseUrl).to.equal('https://api.example.org');
+    });
+  });
+
   describe('fetch', () => {
     it('adds reCache=1 if it is in the current url', async () => {
       const fetchRetrier = new MockFetchRetrier();
-      const fetchHandler = new IaFetchHandler({
+      const fetchHandler = new FetchHandler({
         fetchRetrier: fetchRetrier,
         searchParams: '?reCache=1',
       });
@@ -19,7 +52,7 @@ describe('Fetch Handler', () => {
 
     it('appends reCache=1 when request is a Request object', async () => {
       const fetchRetrier = new MockFetchRetrier();
-      const fetchHandler = new IaFetchHandler({
+      const fetchHandler = new FetchHandler({
         fetchRetrier,
         searchParams: '?reCache=1',
       });
@@ -32,7 +65,7 @@ describe('Fetch Handler', () => {
 
     it('does not append reCache when not present', async () => {
       const fetchRetrier = new MockFetchRetrier();
-      const fetchHandler = new IaFetchHandler({
+      const fetchHandler = new FetchHandler({
         fetchRetrier,
         searchParams: '?foo=bar',
       });
@@ -41,27 +74,37 @@ describe('Fetch Handler', () => {
     });
   });
 
-  describe('fetchIAApiResponse', () => {
+  describe('fetchApiPathResponse', () => {
     it('prepends the IA basehost to the url when making a request', async () => {
       const endpoint = '/foo/service/endpoint.php';
       const fetchRetrier = new MockFetchRetrier();
-      const fetchHandler = new IaFetchHandler({
-        iaApiBaseUrl: 'www.example.com',
+      const fetchHandler = new FetchHandler({
+        apiBaseUrl: 'www.example.com',
         fetchRetrier: fetchRetrier,
       });
-      await fetchHandler.fetchIAApiResponse(endpoint);
+      await fetchHandler.fetchApiPathResponse(endpoint);
       expect(fetchRetrier.requestInfo).to.equal(
         'www.example.com/foo/service/endpoint.php',
       );
     });
+
+    it('defaults to no apiBaseUrl', async () => {
+      const endpoint = '/foo/service/endpoint.php';
+      const fetchRetrier = new MockFetchRetrier();
+      const fetchHandler = new FetchHandler({
+        fetchRetrier: fetchRetrier,
+      });
+      await fetchHandler.fetchApiPathResponse(endpoint);
+      expect(fetchRetrier.requestInfo).to.equal('/foo/service/endpoint.php');
+    });
   });
 
   describe('fetchApiResponse', () => {
     it('adds credentials: include if requested', async () => {
       const endpoint = '/foo/service/endpoint.php';
       const fetchRetrier = new MockFetchRetrier();
-      const fetchHandler = new IaFetchHandler({
-        iaApiBaseUrl: 'www.example.com',
+      const fetchHandler = new FetchHandler({
+        apiBaseUrl: 'www.example.com',
         fetchRetrier: fetchRetrier,
       });
       await fetchHandler.fetchApiResponse(endpoint, {
@@ -72,7 +115,7 @@ describe('Fetch Handler', () => {
 
     it('passes method, body, and headers to RequestInit', async () => {
       const fetchRetrier = new MockFetchRetrier();
-      const fetchHandler = new IaFetchHandler({ fetchRetrier });
+      const fetchHandler = new FetchHandler({ fetchRetrier });
       const body = JSON.stringify({ hello: 'world' });
       await fetchHandler.fetchApiResponse('https://example.org/api', {
         method: 'POST',
@@ -89,11 +132,26 @@ describe('Fetch Handler', () => {
     it('passes retryConfig through to retrier', async () => {
       const fetchRetrier = new MockFetchRetrier();
       const retryConfig = new NoRetryConfiguration();
-      const fetchHandler = new IaFetchHandler({ fetchRetrier });
+      const fetchHandler = new FetchHandler({ fetchRetrier });
       await fetchHandler.fetchApiResponse('https://example.org/api', {
         retryConfig,
       });
       expect(fetchRetrier.retryConfig).to.equal(retryConfig);
     });
   });
+
+  describe('fetchIAApiResponse', () => {
+    it('is an alias for fetchApiPathResponse', async () => {
+      const endpoint = '/foo/service/endpoint.php';
+      const fetchRetrier = new MockFetchRetrier();
+      const fetchHandler = new FetchHandler({
+        iaApiBaseUrl: 'www.example.com',
+        fetchRetrier: fetchRetrier,
+      });
+      await fetchHandler.fetchIAApiResponse(endpoint);
+      expect(fetchRetrier.requestInfo).to.equal(
+        'www.example.com/foo/service/endpoint.php',
+      );
+    });
+  });
 });

package/test/fetch-retrier.test.ts

@@ -21,7 +21,7 @@ describe('FetchRetrier', () => {
     fetchStub.resolves(new Response('ok', { status: 200 }));
     const retrier = new FetchRetrier({
       analyticsHandler: analytics,
-      retryConfiguration: new MockRetryConfig(),
+      retryConfig: new MockRetryConfig(),
     });
 
     const res = await retrier.fetchRetry('https://foo.org/data');
@@ -81,7 +81,7 @@ describe('FetchRetrier', () => {
 
     const retrier = new FetchRetrier({
       analyticsHandler: analytics,
-      retryConfiguration: new MockRetryConfig(),
+      retryConfig: new MockRetryConfig(),
     });
 
     const res = await retrier.fetchRetry('https://foo.org/fail');
@@ -98,7 +98,7 @@ describe('FetchRetrier', () => {
 
     const retrier = new FetchRetrier({
       analyticsHandler: analytics,
-      retryConfiguration: new MockRetryConfig(),
+      retryConfig: new MockRetryConfig(),
     });
 
     const res = await retrier.fetchRetry('https://foo.org/retry');
@@ -113,7 +113,7 @@ describe('FetchRetrier', () => {
 
     const retrier = new FetchRetrier({
       analyticsHandler: analytics,
-      retryConfiguration: new MockRetryConfig(),
+      retryConfig: new MockRetryConfig(),
     });
 
     try {
@@ -157,7 +157,7 @@ describe('FetchRetrier', () => {
 
     const retrier = new FetchRetrier({
       analyticsHandler: analytics,
-      retryConfiguration: retryConfig,
+      retryConfig: retryConfig,
     });
 
     const res = await retrier.fetchRetry('https://foo.org/retry-fail');
@@ -171,7 +171,7 @@ describe('FetchRetrier', () => {
     fetchStub.resolves(new Response('server error', { status: 500 }));
     const retrier = new FetchRetrier({
       analyticsHandler: analytics,
-      retryConfiguration: new (class {
+      retryConfig: new (class {
         shouldRetry() {
           return false;
         }
@@ -191,7 +191,7 @@ describe('FetchRetrier', () => {
     fetchStub.rejects(new Error('Immediate failure'));
     const retrier = new FetchRetrier({
       analyticsHandler: analytics,
-      retryConfiguration: new (class {
+      retryConfig: new (class {
         shouldRetry() {
           return false;
         }

package/test/legacy-args.test.ts

@@ -1,6 +1,7 @@
 import { expect } from '@open-wc/testing';
 import { legacyArgsAsFetchOptions } from '../src/fetch-retry/legacy-args';
 import type { FetchOptions } from '../src/fetch-options';
+import { MockRetryConfig } from './mocks/mock-retry-config';
 
 describe('legacyArgsAsFetchOptions', () => {
   it('wraps RequestInit into FetchOptions', () => {
@@ -10,8 +11,10 @@ describe('legacyArgsAsFetchOptions', () => {
   });
 
   it('returns FetchOptions unchanged', () => {
+    const retryConfig = new MockRetryConfig();
     const options: FetchOptions = {
       requestInit: { headers: { foo: 'bar' } },
+      retryConfig: retryConfig,
     };
     const fo = legacyArgsAsFetchOptions(options);
     expect(fo).to.equal(options);

package/test/mocks/mock-retry-config.ts

@@ -5,11 +5,7 @@ export class MockRetryConfig implements RetryConfiguring {
 
   mockRetryDelay: number = 0;
 
-  shouldRetry(
-    response: Response | null,
-    retryNumber: number,
-    error?: unknown,
-  ): boolean {
+  shouldRetry(response: Response | null, retryNumber: number): boolean {
     return retryNumber < this.mockRetryCount;
   }
 

package/test/no-retry-config.test.ts

@@ -9,6 +9,6 @@ describe('NoRetryConfiguration', () => {
 
   it('has no delay', async () => {
     const config = new NoRetryConfiguration();
-    expect(config.retryDelay()).to.equal(0);
+    expect(config.retryDelay()).to.be.null;
   });
 });

package/dist/test/retrier-legacy-args.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/test/retrier-legacy-args.test.js

@@ -1,27 +0,0 @@
-import { expect } from '@open-wc/testing';
-import { legacyArgsAsFetchOptions } from '../src/fetch-retry/legacy-args';
-import { MockRetryConfig } from './mocks/mock-retry-config';
-describe('FetchRetrier Legacy Args', () => {
-    it('can convert RequestInit to FetchOptions', async () => {
-        const options = legacyArgsAsFetchOptions({ method: 'GET' });
-        expect(options).to.deep.equal({
-            requestInit: {
-                method: 'GET',
-            },
-        });
-    });
-    it('leaves FetchOptions unchanged', async () => {
-        const retryConfig = new MockRetryConfig();
-        const options = legacyArgsAsFetchOptions({
-            requestInit: { method: 'POST' },
-            retryConfig: retryConfig,
-        });
-        expect(options).to.deep.equal({
-            requestInit: {
-                method: 'POST',
-            },
-            retryConfig: retryConfig,
-        });
-    });
-});
-//# sourceMappingURL=retrier-legacy-args.test.js.map

package/dist/test/retrier-legacy-args.test.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"retrier-legacy-args.test.js","sourceRoot":"","sources":["../../test/retrier-legacy-args.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC1C,OAAO,EAAE,wBAAwB,EAAE,MAAM,gCAAgC,CAAC;AAC1E,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAE5D,QAAQ,CAAC,0BAA0B,EAAE,GAAG,EAAE;IACxC,EAAE,CAAC,yCAAyC,EAAE,KAAK,IAAI,EAAE;QACvD,MAAM,OAAO,GAAG,wBAAwB,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC;QAC5D,MAAM,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC;YAC5B,WAAW,EAAE;gBACX,MAAM,EAAE,KAAK;aACd;SACF,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,+BAA+B,EAAE,KAAK,IAAI,EAAE;QAC7C,MAAM,WAAW,GAAG,IAAI,eAAe,EAAE,CAAC;QAC1C,MAAM,OAAO,GAAG,wBAAwB,CAAC;YACvC,WAAW,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE;YAC/B,WAAW,EAAE,WAAW;SACzB,CAAC,CAAC;QACH,MAAM,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC;YAC5B,WAAW,EAAE;gBACX,MAAM,EAAE,MAAM;aACf;YACD,WAAW,EAAE,WAAW;SACzB,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC","sourcesContent":["import { expect } from '@open-wc/testing';\nimport { legacyArgsAsFetchOptions } from '../src/fetch-retry/legacy-args';\nimport { MockRetryConfig } from './mocks/mock-retry-config';\n\ndescribe('FetchRetrier Legacy Args', () => {\n  it('can convert RequestInit to FetchOptions', async () => {\n    const options = legacyArgsAsFetchOptions({ method: 'GET' });\n    expect(options).to.deep.equal({\n      requestInit: {\n        method: 'GET',\n      },\n    });\n  });\n\n  it('leaves FetchOptions unchanged', async () => {\n    const retryConfig = new MockRetryConfig();\n    const options = legacyArgsAsFetchOptions({\n      requestInit: { method: 'POST' },\n      retryConfig: retryConfig,\n    });\n    expect(options).to.deep.equal({\n      requestInit: {\n        method: 'POST',\n      },\n      retryConfig: retryConfig,\n    });\n  });\n});\n"]}

package/test/retrier-legacy-args.test.ts

@@ -1,28 +0,0 @@
-import { expect } from '@open-wc/testing';
-import { legacyArgsAsFetchOptions } from '../src/fetch-retry/legacy-args';
-import { MockRetryConfig } from './mocks/mock-retry-config';
-
-describe('FetchRetrier Legacy Args', () => {
-  it('can convert RequestInit to FetchOptions', async () => {
-    const options = legacyArgsAsFetchOptions({ method: 'GET' });
-    expect(options).to.deep.equal({
-      requestInit: {
-        method: 'GET',
-      },
-    });
-  });
-
-  it('leaves FetchOptions unchanged', async () => {
-    const retryConfig = new MockRetryConfig();
-    const options = legacyArgsAsFetchOptions({
-      requestInit: { method: 'POST' },
-      retryConfig: retryConfig,
-    });
-    expect(options).to.deep.equal({
-      requestInit: {
-        method: 'POST',
-      },
-      retryConfig: retryConfig,
-    });
-  });
-});