feat(types): self-contained FetchLike type so consumers w/o DOM lib compile

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: cubehouse

src/client.ts

@@ -2,7 +2,7 @@ import { InMemoryLruCache, ttlForPath, type Cache } from './cache';
 import { DestinationsApi } from './ergonomic/destinations';
 import { EntityHandle } from './ergonomic/entity';
 import { RawClient } from './raw';
-import { Transport, type RetryConfig } from './transport';
+import { Transport, type FetchLike, type RetryConfig } from './transport';
 
 const DEFAULT_BASE_URL = 'https://api.themeparks.wiki/v1';
 const PACKAGE_VERSION = '7.0.0-alpha.0';
@@ -11,7 +11,7 @@ const DEFAULT_USER_AGENT = `themeparks-sdk-js/${PACKAGE_VERSION}`;
 export interface ThemeParksOptions {
   baseUrl?: string;
   userAgent?: string;
-  fetch?: typeof globalThis.fetch;
+  fetch?: FetchLike;
   timeoutMs?: number;
   retry?: Partial<RetryConfig>;
   cache?: Cache | false | { maxEntries?: number };

src/index.ts

@@ -1,6 +1,7 @@
 export { ThemeParks, type ThemeParksOptions } from './client';
 export { ApiError, NetworkError, RateLimitError, ThemeParksError, TimeoutError } from './errors';
 export { InMemoryLruCache, type Cache } from './cache';
+export type { FetchLike, FetchLikeResponse, RetryConfig, TransportOptions } from './transport';
 export type { Destinations, Entity, EntityChildren, EntityLive, EntitySchedule } from './raw';
 export {
   currentWaitTime,

src/transport.ts

@@ -1,5 +1,36 @@
 import { ApiError, NetworkError, RateLimitError, TimeoutError } from './errors';
 
+/**
+ * Minimal fetch-like function signature covering only what the SDK uses.
+ *
+ * Defined locally so consumers without the DOM lib (e.g. Node-only projects
+ * with `lib: ["ES2022"]` and older `@types/node`) don't pull `globalThis.fetch`,
+ * `Response`, or `RequestInit` into their emitted `.d.ts` when they import
+ * this SDK's types.
+ *
+ * At runtime the SDK still calls `globalThis.fetch` by default; this type is
+ * purely a structural subset so any spec-compatible `fetch` implementation
+ * (node's built-in, undici, whatwg-fetch, a user mock, etc.) satisfies it.
+ */
+export type FetchLike = (
+  input: string | URL,
+  init?: {
+    method?: string;
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+    body?: string;
+  },
+) => Promise<FetchLikeResponse>;
+
+export interface FetchLikeResponse {
+  ok: boolean;
+  status: number;
+  statusText: string;
+  headers: { get(name: string): string | null };
+  json(): Promise<unknown>;
+  text(): Promise<string>;
+}
+
 /**
  * Retry configuration for the {@link Transport}.
  *
@@ -29,7 +60,7 @@ export interface TransportOptions {
    * initial attempt, so `{ max: 3 }` permits up to 4 total calls.
    */
   retry: RetryConfig;
-  fetch: typeof globalThis.fetch;
+  fetch: FetchLike;
   sleep?: (ms: number) => Promise<void>;
 }
 
@@ -102,7 +133,7 @@ export class Transport {
       const timer = setTimeout(() => {
         controller.abort();
       }, this.opts.timeoutMs);
-      let response: Response;
+      let response: FetchLikeResponse;
       try {
         response = await this.opts.fetch(url, {
           method,
@@ -166,7 +197,7 @@ export class Transport {
     }
   }
 
-  private async safeParseBody(response: Response): Promise<unknown> {
+  private async safeParseBody(response: FetchLikeResponse): Promise<unknown> {
     const ct = response.headers.get('content-type') ?? '';
     if (!ct.includes('application/json')) {
       try {

test/unit/transport.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi } from 'vitest';
-import { Transport } from '../../src/transport';
+import { Transport, type FetchLike } from '../../src/transport';
 import { ApiError, NetworkError, RateLimitError, TimeoutError } from '../../src/errors';
 
 function jsonResponse(body: unknown, init: ResponseInit = {}): Response {
@@ -125,6 +125,30 @@ describe('Transport', () => {
     await expect(t.get('/x')).rejects.toMatchObject({ name: 'NetworkError' });
   });
 
+  it('accepts a custom FetchLike-typed fetch implementation', async () => {
+    // Type-level exercise: assign to FetchLike without any DOM types in scope
+    // of the signature. Runtime uses a small mock.
+    const myFetch: FetchLike = (_input, _init) =>
+      Promise.resolve({
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        headers: {
+          get: (_name: string): string | null => 'application/json',
+        },
+        json: (): Promise<unknown> => Promise.resolve({ hello: 'world' }),
+        text: (): Promise<string> => Promise.resolve('{"hello":"world"}'),
+      });
+    const t = new Transport({
+      baseUrl: 'https://api.example/v1',
+      userAgent: 'test/1',
+      timeoutMs: 1000,
+      retry: { max: 0, on429: true },
+      fetch: myFetch,
+    });
+    await expect(t.get('/x')).resolves.toEqual({ hello: 'world' });
+  });
+
   it('throws TimeoutError when the request exceeds timeoutMs', async () => {
     const fetchFn = vi.fn().mockImplementation(
       (_url: string, init: RequestInit) =>