@nlabs/rip-hunter 3.0.2 → 3.1.0

package/.github/copilot-instructions.md

@@ -0,0 +1,46 @@
+# Rip Hunter: AI Coding Guidelines
+
+## Project Overview
+Rip Hunter is an ESM-first TypeScript HTTP client library supporting REST APIs, GraphQL queries/mutations/subscriptions, and Server-Sent Events (SSE). Key features include request caching, deduplication, timeouts, and automatic reconnection for real-time features.
+
+## Architecture
+- **Core Exports**: `get`, `post`, `put`, `del`, `ajax` for REST; `query`, `mutation`, `subscribe` for GraphQL; `subscribeSSE` for SSE
+- **Error Handling**: Use `ApiError` class from `./errors/ApiError.js` - extends Error with `source` and `errors` array
+- **Request Deduplication**: Automatic via `requestCache` Map using base64-encoded keys from method/URL/params/options
+- **Caching**: GET requests cached by default when `cache: true` in options
+- **Real-time**: GraphQL subscriptions use WebSocket with `graphql-ws` protocol; SSE uses EventSource (install `eventsource` for Node.js)
+
+## Development Workflow
+- **Build**: `npm run build` (lex compile --remove) outputs to `lib/` with .d.ts declarations
+- **Test**: `npm run test` (lex test) uses Jest with @nlabs/fetch-mock; reset mocks in beforeEach/afterEach
+- **Lint**: `npm run lint` (lex lint --fix) enforces code style
+- **Benchmark**: `npm run benchmark` tests utility function performance
+
+## Code Patterns
+- **Imports**: Use ESM imports with `.js` extensions (e.g., `import { get } from './index.js'`)
+- **TypeScript**: Interfaces prefixed with `Hunter*Type` (e.g., `HunterOptionsType`)
+- **Utilities**: `toGql()` converts objects to GraphQL literals; `queryString()` encodes URL params; `removeSpaces()` cleans GraphQL strings
+- **Options**: Pass `token` for auth, `timeout` in ms, `variables` for GraphQL, `headers` as Headers object
+- **GraphQL Variables**: Use `variables` object; convert to GQL with `toGql(input)` in mutations
+- **Subscriptions**: Return unsubscribe function; handle `onNext`, `onError`, `onComplete`, `onReconnect`
+
+## Examples
+```typescript
+// REST with caching
+const data = await get(url, params, { cache: true, token: 'jwt' });
+
+// GraphQL query
+const result = await query(url, '{ user { id name } }', { timeout: 10000 });
+
+// Subscription
+const unsubscribe = subscribe(wsUrl, 'subscription { userUpdated { id name } }', {
+  onNext: data => console.log(data.userUpdated)
+}, { token: 'jwt', maxReconnectAttempts: 10 });
+```
+
+## Key Files
+- `src/index.ts`: Main implementation with all exports
+- `src/errors/ApiError.ts`: Custom error class
+- `src/index.test.ts`: Comprehensive Jest tests with fetch mocking
+- `package.json`: ESM exports for main and errors subpaths</content>
+<parameter name="filePath">/Users/nitrog7/Development/rip-hunter/.github/copilot-instructions.md

package/README.md

@@ -13,7 +13,7 @@
 
 ---
 
-## 🚀 Why rip-hunter?
+## Why rip-hunter?
 
 - **Unified API**: One package for both REST and GraphQL endpoints
 - **ESM & TypeScript Native**: Modern, type-safe, and tree-shakable
@@ -25,10 +25,11 @@
 - **Timeout Support**: Configurable request timeouts
 - **Request Deduplication**: Prevents duplicate requests
 - **Real-time Updates**: Server-Sent Events (SSE) support
+- **GraphQL Subscriptions**: WebSocket-based subscriptions with automatic reconnection
 
 ---
 
-## 📦 Installation
+## Installation
 
 ```bash
 npm install @nlabs/rip-hunter
@@ -77,6 +78,50 @@ const mutationGql = `mutation { createUser(input: ${toGql(input)}) { id name } }
 const created = await mutation(url, mutationGql, { timeout: 5000 });
 ```
 
+### GraphQL Subscription Example
+
+```js
+import { subscribe } from '@nlabs/rip-hunter';
+
+// Subscribe to real-time GraphQL updates
+const unsubscribe = subscribe(
+  'wss://api.example.com/graphql',
+  `
+    subscription {
+      userUpdated {
+        id
+        name
+        email
+      }
+    }
+  `,
+  {
+    onNext: (data) => {
+      console.log('User updated:', data.userUpdated);
+    },
+    onError: (error) => {
+      console.error('Subscription error:', error);
+    },
+    onComplete: () => {
+      console.log('Subscription completed');
+    },
+    onReconnect: (attempt) => {
+      console.log(`Reconnecting... (attempt ${attempt})`);
+    }
+  },
+  {
+    token: 'your_jwt_token',
+    variables: { userId: '123' },
+    connectionParams: { clientId: 'my-client' },
+    maxReconnectAttempts: 10,
+    reconnectInterval: 1000
+  }
+);
+
+// Later, to unsubscribe:
+unsubscribe();
+```
+
 ### SSE Example
 
 ```js
@@ -178,6 +223,27 @@ Send a GraphQL mutation.
 - **options**: `{ headers?, token?, variables?, stripWhitespace?, timeout? }`
 - **Returns**: `Promise<any>`
 
+#### `subscribe(url, query, callbacks, options?)`
+
+Subscribe to a GraphQL subscription over WebSocket (graphql-ws protocol).
+
+- **url**: `string` – WebSocket URL (ws:// or wss://)
+- **query**: `string` – GraphQL subscription query string
+- **callbacks**: `HunterSubscriptionCallbackType` – Event handlers
+  - `onNext?: (data: any) => void` – Called when new data arrives
+  - `onError?: (error: Error | Event) => void` – Called on errors
+  - `onComplete?: () => void` – Called when subscription completes
+  - `onReconnect?: (attempt: number) => void` – Called during reconnection attempts
+- **options**: `HunterSubscriptionOptionsType`
+  - `token?: string` – Authentication token
+  - `variables?: Record<string, unknown>` – GraphQL variables
+  - `connectionParams?: Record<string, unknown>` – WebSocket connection parameters
+  - `maxReconnectAttempts?: number` – Maximum reconnection attempts (default: 5)
+  - `reconnectInterval?: number` – Delay between reconnection attempts in ms (default: 1000)
+  - `timeout?: number` – Connection timeout
+  - `headers?: Headers` – Custom headers
+- **Returns**: `() => void` – Unsubscribe function
+
 #### `graphqlQuery(url, query, options?)`
 
 Low-level GraphQL request.
@@ -254,7 +320,7 @@ All errors are wrapped in a consistent `ApiError` object for easy handling.
 
 ---
 
-## 💡 Advanced Usage
+## Advanced Usage
 
 ### Request Caching
 
@@ -319,7 +385,7 @@ const unsubscribe = subscribeSSE('/api/notifications', {
 
 ---
 
-## 🚀 Performance Features
+## Performance Features
 
 - **Request Deduplication**: Prevents duplicate requests to the same endpoint
 - **Built-in Caching**: Automatic caching for GET requests with 5-minute TTL
@@ -330,7 +396,7 @@ const unsubscribe = subscribeSSE('/api/notifications', {
 
 ---
 
-## 🌐 Environment Support
+## Environment Support
 
 - **Browser**: Full support for all features including SSE
 - **Node.js**: Full REST/GraphQL support, SSE requires `eventsource` package
@@ -338,11 +404,11 @@ const unsubscribe = subscribeSSE('/api/notifications', {
 
 ---
 
-## 🤝 Contributing
+## Contributing
 
 PRs and issues welcome! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
 
-## 📄 License
+## License
 
 MIT © Nitrogen Labs, Inc.
 

package/lib/errors/ApiError.d.ts

@@ -7,3 +7,4 @@ export declare class ApiError extends Error {
     errors: string[];
     constructor(list: any, error: any);
 }
+//# sourceMappingURL=ApiError.d.ts.map

package/lib/errors/ApiError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiError.d.ts","sourceRoot":"","sources":["../../src/errors/ApiError.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,qBAAa,QAAS,SAAQ,KAAK;IACjC,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,MAAM,EAAE,CAAC;gBAEL,IAAI,KAAA,EAAE,KAAK,KAAA;CAKxB"}

package/lib/errors/ApiError.js

@@ -1,2 +1,14 @@
-class t extends Error{source;errors;constructor(r,s){super("API Error"),this.source=s,this.errors=r?r.map(o=>o.message):[]}}export{t as ApiError};
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL2Vycm9ycy9BcGlFcnJvci50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBDb3B5cmlnaHQgKGMpIDIwMTctUHJlc2VudCwgTml0cm9nZW4gTGFicywgSW5jLlxuICogQ29weXJpZ2h0cyBsaWNlbnNlZCB1bmRlciB0aGUgTUlUIExpY2Vuc2UuIFNlZSB0aGUgYWNjb21wYW55aW5nIExJQ0VOU0UgZmlsZSBmb3IgdGVybXMuXG4gKi9cbmV4cG9ydCBjbGFzcyBBcGlFcnJvciBleHRlbmRzIEVycm9yIHtcbiAgc291cmNlOiBFcnJvcjtcbiAgZXJyb3JzOiBzdHJpbmdbXTtcblxuICBjb25zdHJ1Y3RvcihsaXN0LCBlcnJvcikge1xuICAgIHN1cGVyKCdBUEkgRXJyb3InKTtcbiAgICB0aGlzLnNvdXJjZSA9IGVycm9yO1xuICAgIHRoaXMuZXJyb3JzID0gbGlzdCA/IGxpc3QubWFwKChlcnJvckl0ZW06IEVycm9yKSA9PiBlcnJvckl0ZW0ubWVzc2FnZSkgOiBbXTtcbiAgfVxufVxuIl0sCiAgIm1hcHBpbmdzIjogIkFBSU8sTUFBTUEsVUFBaUIsS0FBTSxDQUNsQyxPQUNBLE9BRUEsWUFBWUMsRUFBTUMsRUFBTyxDQUN2QixNQUFNLFdBQVcsRUFDakIsS0FBSyxPQUFTQSxFQUNkLEtBQUssT0FBU0QsRUFBT0EsRUFBSyxJQUFLRSxHQUFxQkEsRUFBVSxPQUFPLEVBQUksQ0FBQyxDQUM1RSxDQUNGIiwKICAibmFtZXMiOiBbIkFwaUVycm9yIiwgImxpc3QiLCAiZXJyb3IiLCAiZXJyb3JJdGVtIl0KfQo=
+/**
+ * Copyright (c) 2017-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ export class ApiError extends Error {
+    source;
+    errors;
+    constructor(list, error){
+        super('API Error');
+        this.source = error;
+        this.errors = list ? list.map((errorItem)=>errorItem.message) : [];
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9Vc2Vycy9uaXRyb2c3L0RldmVsb3BtZW50L3JpcC1odW50ZXIvc3JjL2Vycm9ycy9BcGlFcnJvci50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIENvcHlyaWdodCAoYykgMjAxNy1QcmVzZW50LCBOaXRyb2dlbiBMYWJzLCBJbmMuXG4gKiBDb3B5cmlnaHRzIGxpY2Vuc2VkIHVuZGVyIHRoZSBNSVQgTGljZW5zZS4gU2VlIHRoZSBhY2NvbXBhbnlpbmcgTElDRU5TRSBmaWxlIGZvciB0ZXJtcy5cbiAqL1xuZXhwb3J0IGNsYXNzIEFwaUVycm9yIGV4dGVuZHMgRXJyb3Ige1xuICBzb3VyY2U6IEVycm9yO1xuICBlcnJvcnM6IHN0cmluZ1tdO1xuXG4gIGNvbnN0cnVjdG9yKGxpc3QsIGVycm9yKSB7XG4gICAgc3VwZXIoJ0FQSSBFcnJvcicpO1xuICAgIHRoaXMuc291cmNlID0gZXJyb3I7XG4gICAgdGhpcy5lcnJvcnMgPSBsaXN0ID8gbGlzdC5tYXAoKGVycm9ySXRlbTogRXJyb3IpID0+IGVycm9ySXRlbS5tZXNzYWdlKSA6IFtdO1xuICB9XG59XG4iXSwibmFtZXMiOlsiQXBpRXJyb3IiLCJFcnJvciIsInNvdXJjZSIsImVycm9ycyIsImxpc3QiLCJlcnJvciIsIm1hcCIsImVycm9ySXRlbSIsIm1lc3NhZ2UiXSwibWFwcGluZ3MiOiJBQUFBOzs7Q0FHQyxHQUNELE9BQU8sTUFBTUEsaUJBQWlCQztJQUM1QkMsT0FBYztJQUNkQyxPQUFpQjtJQUVqQixZQUFZQyxJQUFJLEVBQUVDLEtBQUssQ0FBRTtRQUN2QixLQUFLLENBQUM7UUFDTixJQUFJLENBQUNILE1BQU0sR0FBR0c7UUFDZCxJQUFJLENBQUNGLE1BQU0sR0FBR0MsT0FBT0EsS0FBS0UsR0FBRyxDQUFDLENBQUNDLFlBQXFCQSxVQUFVQyxPQUFPLElBQUksRUFBRTtJQUM3RTtBQUNGIn0=

package/lib/index.d.ts

@@ -32,6 +32,21 @@ export interface HunterSSECallbackType {
     onError?: (error: Error | Event) => void;
     onRetry?: (attempt: number, delay: number) => void;
 }
+export interface HunterSubscriptionOptionsType {
+    readonly headers?: Headers;
+    readonly token?: string;
+    readonly variables?: Record<string, unknown>;
+    readonly connectionParams?: Record<string, unknown>;
+    readonly reconnectInterval?: number;
+    readonly maxReconnectAttempts?: number;
+    readonly timeout?: number;
+}
+export interface HunterSubscriptionCallbackType {
+    onNext?: (data: any) => void;
+    onError?: (error: Error | Event) => void;
+    onComplete?: () => void;
+    onReconnect?: (attempt: number) => void;
+}
 export declare const removeSpaces: (str: string) => string;
 export declare const queryString: (json: any) => string;
 export declare const ajax: (url: string, method: string, params?: any, options?: HunterOptionsType) => Promise<any>;
@@ -43,5 +58,7 @@ export declare const toGql: (obj: any) => string;
 export declare const graphqlQuery: (url: string, query: HunterQueryType | HunterQueryType[], options?: HunterOptionsType) => Promise<any>;
 export declare const query: (url: string, body: string, options?: HunterOptionsType) => Promise<any>;
 export declare const mutation: (url: string, body: string, options?: HunterOptionsType) => Promise<any>;
+export declare const subscribe: (url: string, query: string, callbacks: HunterSubscriptionCallbackType, options?: HunterSubscriptionOptionsType) => (() => void);
 export declare const subscribeSSE: (url: string, callbacks: HunterSSECallbackType, options?: HunterSSEOptionsType) => (() => void);
 export { ApiError } from './errors/ApiError.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

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

package/lib/index.js

@@ -1,2 +1,550 @@
-import{ApiError as l}from"./errors/ApiError.js";import{ApiError as B}from"./errors/ApiError.js";const v=e=>Array.isArray(e),q=e=>typeof e=="string",P=e=>e!==null&&typeof e=="object"&&!v(e),H=e=>e==null||e==="",C=e=>e===null,R=e=>e===void 0,w=/application\/json/i,S=new Map,A=e=>e.replace(/\s+(?=(?:[^'"]*['"][^'"]*['"])*[^'"]*$)/gm,""),J=e=>Object.keys(e).map(r=>`${encodeURIComponent(r)}=${encodeURIComponent(e[r])}`).join("&"),x=e=>new Promise((r,t)=>setTimeout(()=>t(new Error("Request timeout")),e)),O=(e,r,t,i)=>{const a=JSON.stringify({method:r,options:i,params:t,url:e});return btoa(a).slice(0,50)},N=(e,r)=>{if(typeof EventSource<"u")return new EventSource(e);throw new Error('EventSource not available in this environment. For Node.js support, install the "eventsource" package and import it manually.')},T=(e,r,t,i={})=>{const{headers:a,token:c,timeout:m=3e4,cache:f=!1}=i;let p=(e||"").trim();const d=(c||"").trim(),n=a||new Headers,u=(r||"GET").toUpperCase();let s;if(t&&u==="GET"?(p=`${p}?${J(t)}`,s=null):t?(n.set("Accept","application/json"),n.set("Content-Type","application/json"),s=JSON.stringify(t)):s=t,H(d)||n.set("Authorization",`Bearer ${d}`),f&&u==="GET"){const o=O(p,u,t,i),E=S.get(o);if(E)return E}const y=fetch(p,{body:s,headers:n,method:u}).then(o=>w.test(o.headers.get("Content-Type")||"")?o.json():o.text()).then(o=>o).catch(o=>(o||{}).message==="only absolute urls are supported"?Promise.reject(new l([{message:"invalid_url"}],o)):Promise.reject(new l([{message:"network_error"}],o))),g=m>0?Promise.race([y,x(m)]):y;if(f&&u==="GET"){const o=O(p,u,t,i);S.set(o,g),setTimeout(()=>S.delete(o),3e5)}return g},j=(e,r,t)=>T(e,"GET",r,t),b=(e,r,t)=>T(e,"POST",r,t),U=(e,r,t)=>T(e,"PUT",r,t),G=(e,r,t)=>T(e,"DELETE",r,t),h=e=>{if(q(e))return JSON.stringify(e);if(P(e)){const r=[];for(const i in e)if(e.hasOwnProperty(i)){const a=e[i];if(R(a)||C(a))continue;if(P(a))r.push(`${i}: ${h(a)}`);else if(v(a)){const c=a.map(m=>h(m));r.push(`${i}: [${c.join(", ")}]`)}else{const c=JSON.stringify(a);c&&r.push(`${i}: ${c}`)}}return r.join(", ")===""?'""':`{${r.join(", ")}}`}else if(v(e))return`[${e.map(r=>h(r)).join(", ")}]`;return String(e)},$=(e,r,t={})=>{const{headers:i,token:a,timeout:c=3e4}=t,m=e?e.trim():"",f=(a||"").trim(),p=i||new Headers({"Content-Type":"application/json"});H(f)||p.set("Authorization",`Bearer ${f}`);const d=fetch(m,{body:JSON.stringify(r),headers:p,method:"post"}).then(n=>w.test(n.headers.get("Content-Type")||"")&&n.body?n.json():null).catch(n=>(n||{}).message==="only absolute urls are supported"?Promise.reject(new l([{message:"invalid_url"}],n)):Promise.reject(new l([{message:"network_error"}],n))).then(n=>{if(!n||n.errors){if(n){if((n.errors||[]).some(u=>u.message==="Must provide query string."))return Promise.reject(new l([{message:"required_query"}],new Error))}else return Promise.reject(new l([{message:"api_error"}],new Error));return n.errors?Promise.reject(new l(n.errors,new Error)):{}}return n.data||{}}).catch(n=>Promise.reject(n.source?n:new l([{message:"network_error"}],n)));return c>0?Promise.race([d,x(c)]):d},I=(e,r,t={})=>$(e,{query:r},t),M=(e,r,t={})=>$(e,{query:r},t),Q=(e,r,t={})=>{const{headers:i,token:a,timeout:c=3e4,retryInterval:m=1e3,maxRetries:f=5}=t,p=(e||"").trim(),d=(a||"").trim(),n=i||new Headers;H(d)||n.set("Authorization",`Bearer ${d}`);let u=0,s=null,y=null;const g=()=>{try{s=N(p,{headers:n}),c>0&&(y=setTimeout(()=>{s&&(s.close(),r.onError&&r.onError(new Error("SSE connection timeout")))},c)),s.onopen=o=>{y&&(clearTimeout(y),y=null),u=0,r.onOpen&&r.onOpen(o)},s.onmessage=o=>{if(r.onMessage){const E={data:o.data,id:o.lastEventId,retry:o.data.includes("retry:")?parseInt(o.data.split("retry:")[1]):void 0,type:o.type};r.onMessage(E)}},s.onerror=o=>{y&&(clearTimeout(y),y=null),s&&s.readyState===EventSource.CLOSED?u<f?(u++,r.onRetry&&r.onRetry(u,m),setTimeout(g,m)):r.onError&&r.onError(new Error("SSE connection failed after max retries")):r.onError&&r.onError(o)}}catch(o){r.onError&&r.onError(o instanceof Error?o:new Error("Failed to create SSE connection"))}};return g(),()=>{y&&(clearTimeout(y),y=null),s&&(s.close(),s=null)}};export{B as ApiError,T as ajax,G as del,j as get,$ as graphqlQuery,M as mutation,b as post,U as put,I as query,J as queryString,A as removeSpaces,Q as subscribeSSE,h as toGql};
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/index.ts"],
  "sourcesContent": ["/**\n * Copyright (c) 2017-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\n\nimport {ApiError} from './errors/ApiError.js';\n\nconst isArray = (value: any): value is any[] => Array.isArray(value);\nconst isString = (value: any): value is string => typeof value === 'string';\nconst isPlainObject = (value: any): value is Record<string, any> =>\n  value !== null && typeof value === 'object' && !isArray(value);\nconst isEmpty = (value: any): boolean =>\n  value === null || value === undefined || value === '';\nconst isNull = (value: any): boolean => value === null;\nconst isUndefined = (value: any): boolean => value === undefined;\n\n// Cache for compiled regex patterns\nconst JSON_CONTENT_TYPE_REGEX = /application\\/json/i;\n\n// Request cache for deduplication\nconst requestCache = new Map<string, Promise<any>>();\n\nexport interface HunterOptionsType {\n  readonly headers?: Headers;\n  readonly token?: string;\n  readonly variables?: any;\n  readonly timeout?: number;\n  readonly cache?: boolean;\n}\n\nexport interface HunterQueryType {\n  readonly query: string;\n  readonly variables?: any;\n}\n\nexport interface HunterSSEOptionsType {\n  readonly headers?: Headers;\n  readonly token?: string;\n  readonly timeout?: number;\n  readonly retryInterval?: number;\n  readonly maxRetries?: number;\n}\n\nexport interface HunterSSEEventType {\n  readonly data: string;\n  readonly type: string;\n  readonly id?: string;\n  readonly retry?: number | undefined;\n}\n\nexport interface HunterSSECallbackType {\n  onMessage?: (event: HunterSSEEventType) => void;\n  onOpen?: (event: Event) => void;\n  onError?: (error: Error | Event) => void;\n  onRetry?: (attempt: number, delay: number) => void;\n}\n\nexport const removeSpaces = (str: string): string =>\n  str.replace(/\\s+(?=(?:[^'\"]*['\"][^'\"]*['\"])*[^'\"]*$)/gm, '');\n\nexport const queryString = (json: any): string =>\n  Object.keys(json)\n    .map(\n      (key: string) =>\n        `${encodeURIComponent(key)}=${encodeURIComponent(json[key])}`\n    )\n    .join('&');\n\n// Create a timeout promise\nconst createTimeout = (ms: number): Promise<never> =>\n  new Promise((_, reject) =>\n    setTimeout(() => reject(new Error('Request timeout')), ms)\n  );\n\n// Generate cache key for request deduplication\nconst generateCacheKey = (url: string, method: string, params?: any, options?: HunterOptionsType): string => {\n  const key = JSON.stringify({method, options, params, url});\n  return btoa(key).slice(0, 50); // Truncate to reasonable length\n};\n\n// SSE EventSource polyfill for Node.js\nconst createEventSource = (url: string, options?: HunterSSEOptionsType): EventSource => {\n  if(typeof EventSource !== 'undefined') {\n    return new EventSource(url);\n  }\n\n  // For Node.js, we'll throw an error suggesting the user install eventsource\n  throw new Error('EventSource not available in this environment. For Node.js support, install the \"eventsource\" package and import it manually.');\n};\n\n// AJAX\nexport const ajax = (\n  url: string,\n  method: string,\n  params?,\n  options: HunterOptionsType = {}\n): Promise<any> => {\n  const {headers, token, timeout = 30000, cache = false} = options;\n\n  let formatUrl: string = (url || '').trim();\n  const formatToken: string = (token || '').trim();\n  const formatHeaders: Headers = headers || new Headers();\n\n  // Method\n  const formatMethod: string = (method || 'GET').toUpperCase();\n  let formatParams;\n\n  // Parameters\n  if(params && formatMethod === 'GET') {\n    formatUrl = `${formatUrl}?${queryString(params)}`;\n    formatParams = null;\n  } else if(params) {\n    formatHeaders.set('Accept', 'application/json');\n    formatHeaders.set('Content-Type', 'application/json');\n    formatParams = JSON.stringify(params);\n  } else {\n    formatParams = params;\n  }\n\n  // Authentication token\n  if(!isEmpty(formatToken)) {\n    formatHeaders.set('Authorization', `Bearer ${formatToken}`);\n  }\n\n  // Check cache for GET requests\n  if(cache && formatMethod === 'GET') {\n    const cacheKey = generateCacheKey(formatUrl, formatMethod, params, options);\n    const cached = requestCache.get(cacheKey);\n    if(cached) {\n      return cached;\n    }\n  }\n\n  // Create the request promise\n  const requestPromise = fetch(formatUrl, {\n    body: formatParams,\n    headers: formatHeaders,\n    method: formatMethod\n  })\n    .then((response: Response) => {\n      // Check if response is json using cached regex\n      const isResponseJson = JSON_CONTENT_TYPE_REGEX.test(\n        response.headers.get('Content-Type') || ''\n      );\n\n      if(isResponseJson) {\n        return response.json();\n      }\n\n      return response.text();\n    })\n    .then((results) => results) // Simplified - no need for redundant check\n    .catch((error) => {\n      if((error || {}).message === 'only absolute urls are supported') {\n        return Promise.reject(\n          new ApiError([{message: 'invalid_url'}], error)\n        );\n      }\n\n      return Promise.reject(\n        new ApiError([{message: 'network_error'}], error)\n      );\n    });\n\n  // Add timeout if specified\n  const finalPromise = timeout > 0\n    ? Promise.race([requestPromise, createTimeout(timeout)])\n    : requestPromise;\n\n  // Cache the promise for GET requests\n  if(cache && formatMethod === 'GET') {\n    const cacheKey = generateCacheKey(formatUrl, formatMethod, params, options);\n    requestCache.set(cacheKey, finalPromise);\n\n    // Clean up cache after 5 minutes\n    setTimeout(() => requestCache.delete(cacheKey), 300000);\n  }\n\n  return finalPromise;\n};\n\nexport const get = (\n  url: string,\n  params?,\n  options?: HunterOptionsType\n): Promise<any> => ajax(url, 'GET', params, options);\n\nexport const post = (\n  url: string,\n  params?,\n  options?: HunterOptionsType\n): Promise<any> => ajax(url, 'POST', params, options);\n\nexport const put = (\n  url: string,\n  params?,\n  options?: HunterOptionsType\n): Promise<any> => ajax(url, 'PUT', params, options);\n\nexport const del = (\n  url: string,\n  params?,\n  options?: HunterOptionsType\n): Promise<any> => ajax(url, 'DELETE', params, options);\n\n// Optimized toGql function\nexport const toGql = (obj: any): string => {\n  if(isString(obj)) {\n    return JSON.stringify(obj);\n  } else if(isPlainObject(obj)) {\n    // Filter out undefined and null values in one pass\n    const gqlProps: string[] = [];\n\n    for(const key in obj) {\n      if(obj.hasOwnProperty(key)) {\n        const item = obj[key];\n\n        // Skip undefined and null values\n        if(isUndefined(item) || isNull(item)) {\n          continue;\n        }\n\n        if(isPlainObject(item)) {\n          gqlProps.push(`${key}: ${toGql(item)}`);\n        } else if(isArray(item)) {\n          const list = item.map((listItem) => toGql(listItem));\n          gqlProps.push(`${key}: [${list.join(', ')}]`);\n        } else {\n          const val = JSON.stringify(item);\n          if(val) {\n            gqlProps.push(`${key}: ${val}`);\n          }\n        }\n      }\n    }\n\n    const values = gqlProps.join(', ');\n    return values === '' ? '\"\"' : `{${gqlProps.join(', ')}}`;\n  } else if(isArray(obj)) {\n    return `[${obj.map((objItem) => toGql(objItem)).join(', ')}]`;\n  }\n\n  return String(obj);\n};\n\nexport const graphqlQuery = (\n  url: string,\n  query: HunterQueryType | HunterQueryType[],\n  options: HunterOptionsType = {}\n): Promise<any> => {\n  const {headers, token, timeout = 30000} = options;\n  const formatUrl: string = url ? url.trim() : '';\n  const formatToken: string = (token || '').trim();\n  const formatHeaders: Headers =\n    headers || new Headers({'Content-Type': 'application/json'});\n\n  if(!isEmpty(formatToken)) {\n    formatHeaders.set('Authorization', `Bearer ${formatToken}`);\n  }\n\n  const requestPromise = fetch(formatUrl, {\n    body: JSON.stringify(query),\n    headers: formatHeaders,\n    method: 'post'\n  })\n    .then((response: Response) => {\n      const isJson: boolean = JSON_CONTENT_TYPE_REGEX.test(\n        response.headers.get('Content-Type') || ''\n      );\n\n      if(isJson && response.body) {\n        return response.json();\n      }\n\n      return null;\n    })\n    .catch((error) => {\n      if((error || {}).message === 'only absolute urls are supported') {\n        return Promise.reject(\n          new ApiError([{message: 'invalid_url'}], error)\n        );\n      }\n\n      return Promise.reject(\n        new ApiError([{message: 'network_error'}], error)\n      );\n    })\n    .then((json) => {\n      if(!json || json.errors) {\n        if(!json) {\n          return Promise.reject(\n            new ApiError([{message: 'api_error'}], new Error())\n          );\n        } else if(\n          (json.errors || []).some(\n            (error) => error.message === 'Must provide query string.'\n          )\n        ) {\n          return Promise.reject(\n            new ApiError([{message: 'required_query'}], new Error())\n          );\n        }\n\n        return json.errors\n          ? Promise.reject(new ApiError(json.errors, new Error()))\n          : {};\n      }\n\n      return json.data || {};\n    })\n    .catch((error: ApiError) =>\n      // Simplified error handling - no need to create new error if source exists\n      Promise.reject(error.source ? error : new ApiError([{message: 'network_error'}], error))\n    );\n\n  // Add timeout if specified\n  return timeout > 0\n    ? Promise.race([requestPromise, createTimeout(timeout)])\n    : requestPromise;\n};\n\n// Add query and mutation functions for better API consistency\nexport const query = (\n  url: string,\n  body: string,\n  options: HunterOptionsType = {}\n): Promise<any> => graphqlQuery(url, {query: body}, options);\n\nexport const mutation = (\n  url: string,\n  body: string,\n  options: HunterOptionsType = {}\n): Promise<any> => graphqlQuery(url, {query: body}, options);\n\n// SSE Support\nexport const subscribeSSE = (\n  url: string,\n  callbacks: HunterSSECallbackType,\n  options: HunterSSEOptionsType = {}\n): (() => void) => {\n  const {headers, token, timeout = 30000, retryInterval = 1000, maxRetries = 5} = options;\n  const formatUrl: string = (url || '').trim();\n  const formatToken: string = (token || '').trim();\n  const formatHeaders: Headers = headers || new Headers();\n\n  // Add authorization header if token provided\n  if(!isEmpty(formatToken)) {\n    formatHeaders.set('Authorization', `Bearer ${formatToken}`);\n  }\n\n  let retryCount = 0;\n  let eventSource: EventSource | null = null;\n  let timeoutId: NodeJS.Timeout | null = null;\n\n  const connect = (): void => {\n    try {\n      eventSource = createEventSource(formatUrl, {headers: formatHeaders});\n\n      // Set up timeout\n      if(timeout > 0) {\n        timeoutId = setTimeout(() => {\n          if(eventSource) {\n            eventSource.close();\n            if(callbacks.onError) {\n              callbacks.onError(new Error('SSE connection timeout'));\n            }\n          }\n        }, timeout);\n      }\n\n      // Event handlers\n      eventSource.onopen = (event) => {\n        if(timeoutId) {\n          clearTimeout(timeoutId);\n          timeoutId = null;\n        }\n        retryCount = 0; // Reset retry count on successful connection\n        if(callbacks.onOpen) {\n          callbacks.onOpen(event);\n        }\n      };\n\n      eventSource.onmessage = (event) => {\n        if(callbacks.onMessage) {\n          const sseEvent: HunterSSEEventType = {\n            data: event.data,\n            id: event.lastEventId,\n            retry: event.data.includes('retry:') ? parseInt(event.data.split('retry:')[1]) : undefined,\n            type: event.type\n          };\n          callbacks.onMessage(sseEvent);\n        }\n      };\n\n      eventSource.onerror = (event) => {\n        if(timeoutId) {\n          clearTimeout(timeoutId);\n          timeoutId = null;\n        }\n\n        if(eventSource && eventSource.readyState === EventSource.CLOSED) {\n          // Connection closed, attempt retry if within limits\n          if(retryCount < maxRetries) {\n            retryCount++;\n            if(callbacks.onRetry) {\n              callbacks.onRetry(retryCount, retryInterval);\n            }\n            setTimeout(connect, retryInterval);\n          } else {\n            if(callbacks.onError) {\n              callbacks.onError(new Error('SSE connection failed after max retries'));\n            }\n          }\n        } else {\n          if(callbacks.onError) {\n            callbacks.onError(event);\n          }\n        }\n      };\n    } catch(error) {\n      if(callbacks.onError) {\n        callbacks.onError(error instanceof Error ? error : new Error('Failed to create SSE connection'));\n      }\n    }\n  };\n\n  // Start the connection\n  connect();\n\n  // Return cleanup function\n  return () => {\n    if(timeoutId) {\n      clearTimeout(timeoutId);\n      timeoutId = null;\n    }\n    if(eventSource) {\n      eventSource.close();\n      eventSource = null;\n    }\n  };\n};\n\nexport {ApiError} from './errors/ApiError.js';\n"],
  "mappings": "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",
  "names": ["ApiError", "isArray", "value", "isString", "isPlainObject", "isEmpty", "isNull", "isUndefined", "JSON_CONTENT_TYPE_REGEX", "requestCache", "removeSpaces", "str", "queryString", "json", "key", "createTimeout", "ms", "_", "reject", "generateCacheKey", "url", "method", "params", "options", "createEventSource", "ajax", "headers", "token", "timeout", "cache", "formatUrl", "formatToken", "formatHeaders", "formatMethod", "formatParams", "cacheKey", "cached", "requestPromise", "response", "results", "error", "finalPromise", "get", "post", "put", "del", "toGql", "obj", "gqlProps", "item", "list", "listItem", "val", "objItem", "graphqlQuery", "query", "body", "mutation", "subscribeSSE", "callbacks", "retryInterval", "maxRetries", "retryCount", "eventSource", "timeoutId", "connect", "event", "sseEvent"]
}

+/**
+ * Copyright (c) 2017-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { ApiError } from './errors/ApiError.js';
+const isArray = (value)=>Array.isArray(value);
+const isString = (value)=>typeof value === 'string';
+const isPlainObject = (value)=>value !== null && typeof value === 'object' && !isArray(value);
+const isEmpty = (value)=>value === null || value === undefined || value === '';
+const isNull = (value)=>value === null;
+const isUndefined = (value)=>value === undefined;
+// Cache for compiled regex patterns
+const JSON_CONTENT_TYPE_REGEX = /application\/json/i;
+// Request cache for deduplication
+const requestCache = new Map();
+export const removeSpaces = (str)=>str.replace(/\s+(?=(?:[^'"]*['"][^'"]*['"])*[^'"]*$)/gm, '');
+export const queryString = (json)=>Object.keys(json).map((key)=>`${encodeURIComponent(key)}=${encodeURIComponent(json[key])}`).join('&');
+// Create a timeout promise
+const createTimeout = (ms)=>new Promise((_, reject)=>setTimeout(()=>reject(new Error('Request timeout')), ms));
+// Generate cache key for request deduplication
+const generateCacheKey = (url, method, params, options)=>{
+    const key = JSON.stringify({
+        method,
+        options,
+        params,
+        url
+    });
+    return btoa(key).slice(0, 50); // Truncate to reasonable length
+};
+// SSE EventSource polyfill for Node.js
+const createEventSource = (url, options)=>{
+    if (typeof EventSource !== 'undefined') {
+        return new EventSource(url);
+    }
+    // For Node.js, we'll throw an error suggesting the user install eventsource
+    throw new Error('EventSource not available in this environment. For Node.js support, install the "eventsource" package and import it manually.');
+};
+// WebSocket client for GraphQL subscriptions (graphql-ws protocol)
+class GraphQLSubscriptionClient {
+    ws = null;
+    url;
+    options;
+    reconnectAttempts = 0;
+    reconnectTimer = null;
+    messageQueue = [];
+    isConnecting = false;
+    isConnected = false;
+    subscriptions = new Map();
+    messageHandlers = new Map();
+    constructor(url, options = {}){
+        this.url = url;
+        this.options = options;
+    }
+    convertToWebSocketUrl(url) {
+        return url.replace(/^http/, 'ws').replace(/^https/, 'wss');
+    }
+    connect() {
+        return new Promise((resolve, reject)=>{
+            if (this.isConnecting) {
+                return;
+            }
+            this.isConnecting = true;
+            try {
+                const wsUrl = this.convertToWebSocketUrl(this.url);
+                if (typeof WebSocket === 'undefined') {
+                    this.isConnecting = false;
+                    reject(new Error('WebSocket not available in this environment. For Node.js support, you may need to install a WebSocket library.'));
+                    return;
+                }
+                this.ws = new WebSocket(wsUrl, 'graphql-ws');
+                this.ws.onopen = ()=>{
+                    this.isConnecting = false;
+                    this.isConnected = true;
+                    this.reconnectAttempts = 0;
+                    const initMessage = {
+                        type: 'connection_init',
+                        payload: this.options.connectionParams || {}
+                    };
+                    this.send(JSON.stringify(initMessage));
+                    while(this.messageQueue.length > 0){
+                        const message = this.messageQueue.shift();
+                        if (message && this.ws?.readyState === WebSocket.OPEN) {
+                            this.ws.send(message);
+                        }
+                    }
+                    resolve();
+                };
+                this.ws.onerror = (error)=>{
+                    this.isConnecting = false;
+                    if (!this.isConnected) {
+                        reject(error);
+                    }
+                };
+                this.ws.onclose = ()=>{
+                    this.isConnecting = false;
+                    this.isConnected = false;
+                    this.handleReconnect();
+                };
+                this.ws.onmessage = (event)=>{
+                    try {
+                        const message = JSON.parse(event.data);
+                        if (message.type === 'connection_ack') {
+                            return;
+                        }
+                        if (message.type === 'connection_error') {
+                            const error = new Error(message.payload?.message || 'Connection error');
+                            this.subscriptions.forEach((callbacks)=>{
+                                if (callbacks.onError) {
+                                    callbacks.onError(error);
+                                }
+                            });
+                            return;
+                        }
+                        const subscriptionId = message.id;
+                        const callbacks = this.subscriptions.get(subscriptionId);
+                        if (callbacks) {
+                            switch(message.type){
+                                case 'data':
+                                    if (callbacks.onNext) {
+                                        callbacks.onNext(message.payload?.data || message.payload);
+                                    }
+                                    break;
+                                case 'error':
+                                    if (callbacks.onError) {
+                                        const error = new ApiError(Array.isArray(message.payload) ? message.payload : [
+                                            message.payload
+                                        ], new Error('GraphQL subscription error'));
+                                        callbacks.onError(error);
+                                    }
+                                    break;
+                                case 'complete':
+                                    if (callbacks.onComplete) {
+                                        callbacks.onComplete();
+                                    }
+                                    this.subscriptions.delete(subscriptionId);
+                                    const handler = this.messageHandlers.get(subscriptionId);
+                                    if (handler && this.ws) {
+                                        this.ws.removeEventListener('message', handler);
+                                        this.messageHandlers.delete(subscriptionId);
+                                    }
+                                    break;
+                            }
+                        }
+                    } catch (error) {
+                        this.subscriptions.forEach((callbacks)=>{
+                            if (callbacks.onError) {
+                                callbacks.onError(error instanceof Error ? error : new Error('Parse error'));
+                            }
+                        });
+                    }
+                };
+            } catch (error) {
+                this.isConnecting = false;
+                reject(error);
+            }
+        });
+    }
+    handleReconnect() {
+        const { maxReconnectAttempts = 5, reconnectInterval = 1000 } = this.options;
+        if (this.reconnectAttempts < maxReconnectAttempts && this.subscriptions.size > 0) {
+            this.reconnectAttempts++;
+            this.subscriptions.forEach((callbacks)=>{
+                if (callbacks.onReconnect) {
+                    callbacks.onReconnect(this.reconnectAttempts);
+                }
+            });
+            this.reconnectTimer = setTimeout(()=>{
+                this.connect().catch(()=>{});
+            }, reconnectInterval);
+        } else if (this.subscriptions.size > 0) {
+            const error = new Error('WebSocket reconnection failed after max attempts');
+            this.subscriptions.forEach((callbacks)=>{
+                if (callbacks.onError) {
+                    callbacks.onError(error);
+                }
+            });
+        }
+    }
+    send(message) {
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            this.ws.send(message);
+        } else {
+            this.messageQueue.push(message);
+            if (!this.isConnecting && !this.isConnected) {
+                this.connect().catch(()=>{});
+            }
+        }
+    }
+    subscribe(query, variables, callbacks) {
+        const subscriptionId = `sub_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        this.subscriptions.set(subscriptionId, callbacks);
+        const startMessage = {
+            id: subscriptionId,
+            type: 'start',
+            payload: {
+                query,
+                variables: variables || {}
+            }
+        };
+        const ensureConnection = ()=>{
+            if (!this.isConnected && !this.isConnecting) {
+                this.connect().then(()=>{
+                    this.send(JSON.stringify(startMessage));
+                }).catch((error)=>{
+                    if (callbacks.onError) {
+                        callbacks.onError(error);
+                    }
+                });
+            } else if (this.isConnected) {
+                this.send(JSON.stringify(startMessage));
+            }
+        };
+        ensureConnection();
+        return ()=>{
+            const stopMessage = {
+                id: subscriptionId,
+                type: 'stop'
+            };
+            this.send(JSON.stringify(stopMessage));
+            this.subscriptions.delete(subscriptionId);
+            const handler = this.messageHandlers.get(subscriptionId);
+            if (handler && this.ws) {
+                this.ws.removeEventListener('message', handler);
+                this.messageHandlers.delete(subscriptionId);
+            }
+        };
+    }
+    close() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+        this.messageQueue = [];
+        this.subscriptions.clear();
+        this.messageHandlers.clear();
+        this.isConnected = false;
+        this.isConnecting = false;
+    }
+}
+// Subscription client cache
+const subscriptionClients = new Map();
+// AJAX
+export const ajax = (url, method, params, options = {})=>{
+    const { headers, token, timeout = 30000, cache = false } = options;
+    let formatUrl = (url || '').trim();
+    const formatToken = (token || '').trim();
+    const formatHeaders = headers || new Headers();
+    // Method
+    const formatMethod = (method || 'GET').toUpperCase();
+    let formatParams;
+    // Parameters
+    if (params && formatMethod === 'GET') {
+        formatUrl = `${formatUrl}?${queryString(params)}`;
+        formatParams = null;
+    } else if (params) {
+        formatHeaders.set('Accept', 'application/json');
+        formatHeaders.set('Content-Type', 'application/json');
+        formatParams = JSON.stringify(params);
+    } else {
+        formatParams = params;
+    }
+    // Authentication token
+    if (!isEmpty(formatToken)) {
+        formatHeaders.set('Authorization', `Bearer ${formatToken}`);
+    }
+    // Check cache for GET requests
+    if (cache && formatMethod === 'GET') {
+        const cacheKey = generateCacheKey(formatUrl, formatMethod, params, options);
+        const cached = requestCache.get(cacheKey);
+        if (cached) {
+            return cached;
+        }
+    }
+    // Create the request promise
+    const requestPromise = fetch(formatUrl, {
+        body: formatParams,
+        headers: formatHeaders,
+        method: formatMethod
+    }).then((response)=>{
+        // Check if response is json using cached regex
+        const isResponseJson = JSON_CONTENT_TYPE_REGEX.test(response.headers.get('Content-Type') || '');
+        if (isResponseJson) {
+            return response.json();
+        }
+        return response.text();
+    }).then((results)=>results) // Simplified - no need for redundant check
+    .catch((error)=>{
+        if ((error || {}).message === 'only absolute urls are supported') {
+            return Promise.reject(new ApiError([
+                {
+                    message: 'invalid_url'
+                }
+            ], error));
+        }
+        return Promise.reject(new ApiError([
+            {
+                message: 'network_error'
+            }
+        ], error));
+    });
+    // Add timeout if specified
+    const finalPromise = timeout > 0 ? Promise.race([
+        requestPromise,
+        createTimeout(timeout)
+    ]) : requestPromise;
+    // Cache the promise for GET requests
+    if (cache && formatMethod === 'GET') {
+        const cacheKey = generateCacheKey(formatUrl, formatMethod, params, options);
+        requestCache.set(cacheKey, finalPromise);
+        // Clean up cache after 5 minutes
+        setTimeout(()=>requestCache.delete(cacheKey), 300000);
+    }
+    return finalPromise;
+};
+export const get = (url, params, options)=>ajax(url, 'GET', params, options);
+export const post = (url, params, options)=>ajax(url, 'POST', params, options);
+export const put = (url, params, options)=>ajax(url, 'PUT', params, options);
+export const del = (url, params, options)=>ajax(url, 'DELETE', params, options);
+// Optimized toGql function
+export const toGql = (obj)=>{
+    if (isString(obj)) {
+        return JSON.stringify(obj);
+    } else if (isPlainObject(obj)) {
+        // Filter out undefined and null values in one pass
+        const gqlProps = [];
+        for(const key in obj){
+            if (obj.hasOwnProperty(key)) {
+                const item = obj[key];
+                // Skip undefined and null values
+                if (isUndefined(item) || isNull(item)) {
+                    continue;
+                }
+                if (isPlainObject(item)) {
+                    gqlProps.push(`${key}: ${toGql(item)}`);
+                } else if (isArray(item)) {
+                    const list = item.map((listItem)=>toGql(listItem));
+                    gqlProps.push(`${key}: [${list.join(', ')}]`);
+                } else {
+                    const val = JSON.stringify(item);
+                    if (val) {
+                        gqlProps.push(`${key}: ${val}`);
+                    }
+                }
+            }
+        }
+        const values = gqlProps.join(', ');
+        return values === '' ? '""' : `{${gqlProps.join(', ')}}`;
+    } else if (isArray(obj)) {
+        return `[${obj.map((objItem)=>toGql(objItem)).join(', ')}]`;
+    }
+    return String(obj);
+};
+export const graphqlQuery = (url, query, options = {})=>{
+    const { headers, token, timeout = 30000 } = options;
+    const formatUrl = url ? url.trim() : '';
+    const formatToken = (token || '').trim();
+    const formatHeaders = headers || new Headers({
+        'Content-Type': 'application/json'
+    });
+    if (!isEmpty(formatToken)) {
+        formatHeaders.set('Authorization', `Bearer ${formatToken}`);
+    }
+    const requestPromise = fetch(formatUrl, {
+        body: JSON.stringify(query),
+        headers: formatHeaders,
+        method: 'post'
+    }).then((response)=>{
+        const isJson = JSON_CONTENT_TYPE_REGEX.test(response.headers.get('Content-Type') || '');
+        if (isJson && response.body) {
+            return response.json();
+        }
+        return null;
+    }).catch((error)=>{
+        if ((error || {}).message === 'only absolute urls are supported') {
+            return Promise.reject(new ApiError([
+                {
+                    message: 'invalid_url'
+                }
+            ], error));
+        }
+        return Promise.reject(new ApiError([
+            {
+                message: 'network_error'
+            }
+        ], error));
+    }).then((json)=>{
+        if (!json || json.errors) {
+            if (!json) {
+                return Promise.reject(new ApiError([
+                    {
+                        message: 'api_error'
+                    }
+                ], new Error()));
+            } else if ((json.errors || []).some((error)=>error.message === 'Must provide query string.')) {
+                return Promise.reject(new ApiError([
+                    {
+                        message: 'required_query'
+                    }
+                ], new Error()));
+            }
+            return json.errors ? Promise.reject(new ApiError(json.errors, new Error())) : {};
+        }
+        return json.data || {};
+    }).catch((error)=>// Simplified error handling - no need to create new error if source exists
+        Promise.reject(error.source ? error : new ApiError([
+            {
+                message: 'network_error'
+            }
+        ], error)));
+    // Add timeout if specified
+    return timeout > 0 ? Promise.race([
+        requestPromise,
+        createTimeout(timeout)
+    ]) : requestPromise;
+};
+// Add query and mutation functions for better API consistency
+export const query = (url, body, options = {})=>graphqlQuery(url, {
+        query: body
+    }, options);
+export const mutation = (url, body, options = {})=>graphqlQuery(url, {
+        query: body
+    }, options);
+// GraphQL Subscriptions
+export const subscribe = (url, query, callbacks, options = {})=>{
+    const { token, variables, connectionParams, headers } = options;
+    const formatUrl = (url || '').trim();
+    const formatToken = (token || '').trim();
+    if (!formatUrl) {
+        if (callbacks.onError) {
+            callbacks.onError(new Error('Subscription URL is required'));
+        }
+        return ()=>{};
+    }
+    let client = subscriptionClients.get(formatUrl);
+    if (!client) {
+        const clientOptions = {
+            ...options,
+            connectionParams: {
+                ...connectionParams,
+                ...formatToken ? {
+                    authorization: `Bearer ${formatToken}`
+                } : {}
+            }
+        };
+        client = new GraphQLSubscriptionClient(formatUrl, clientOptions);
+        subscriptionClients.set(formatUrl, client);
+    }
+    return client.subscribe(query, variables, callbacks);
+};
+// SSE Support
+export const subscribeSSE = (url, callbacks, options = {})=>{
+    const { headers, token, timeout = 30000, retryInterval = 1000, maxRetries = 5 } = options;
+    const formatUrl = (url || '').trim();
+    const formatToken = (token || '').trim();
+    const formatHeaders = headers || new Headers();
+    // Add authorization header if token provided
+    if (!isEmpty(formatToken)) {
+        formatHeaders.set('Authorization', `Bearer ${formatToken}`);
+    }
+    let retryCount = 0;
+    let eventSource = null;
+    let timeoutId = null;
+    const connect = ()=>{
+        try {
+            eventSource = createEventSource(formatUrl, {
+                headers: formatHeaders
+            });
+            // Set up timeout
+            if (timeout > 0) {
+                timeoutId = setTimeout(()=>{
+                    if (eventSource) {
+                        eventSource.close();
+                        if (callbacks.onError) {
+                            callbacks.onError(new Error('SSE connection timeout'));
+                        }
+                    }
+                }, timeout);
+            }
+            // Event handlers
+            eventSource.onopen = (event)=>{
+                if (timeoutId) {
+                    clearTimeout(timeoutId);
+                    timeoutId = null;
+                }
+                retryCount = 0; // Reset retry count on successful connection
+                if (callbacks.onOpen) {
+                    callbacks.onOpen(event);
+                }
+            };
+            eventSource.onmessage = (event)=>{
+                if (callbacks.onMessage) {
+                    const sseEvent = {
+                        data: event.data,
+                        id: event.lastEventId,
+                        retry: event.data.includes('retry:') ? parseInt(event.data.split('retry:')[1]) : undefined,
+                        type: event.type
+                    };
+                    callbacks.onMessage(sseEvent);
+                }
+            };
+            eventSource.onerror = (event)=>{
+                if (timeoutId) {
+                    clearTimeout(timeoutId);
+                    timeoutId = null;
+                }
+                if (eventSource && eventSource.readyState === EventSource.CLOSED) {
+                    // Connection closed, attempt retry if within limits
+                    if (retryCount < maxRetries) {
+                        retryCount++;
+                        if (callbacks.onRetry) {
+                            callbacks.onRetry(retryCount, retryInterval);
+                        }
+                        setTimeout(connect, retryInterval);
+                    } else {
+                        if (callbacks.onError) {
+                            callbacks.onError(new Error('SSE connection failed after max retries'));
+                        }
+                    }
+                } else {
+                    if (callbacks.onError) {
+                        callbacks.onError(event);
+                    }
+                }
+            };
+        } catch (error) {
+            if (callbacks.onError) {
+                callbacks.onError(error instanceof Error ? error : new Error('Failed to create SSE connection'));
+            }
+        }
+    };
+    // Start the connection
+    connect();
+    // Return cleanup function
+    return ()=>{
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+            timeoutId = null;
+        }
+        if (eventSource) {
+            eventSource.close();
+            eventSource = null;
+        }
+    };
+};
+export { ApiError } from './errors/ApiError.js';
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/rip-hunter/src/index.ts"],"sourcesContent":["/**\n * Copyright (c) 2017-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\n\nimport {ApiError} from './errors/ApiError.js';\n\nconst isArray = (value: any): value is any[] => Array.isArray(value);\nconst isString = (value: any): value is string => typeof value === 'string';\nconst isPlainObject = (value: any): value is Record<string, any> =>\n  value !== null && typeof value === 'object' && !isArray(value);\nconst isEmpty = (value: any): boolean =>\n  value === null || value === undefined || value === '';\nconst isNull = (value: any): boolean => value === null;\nconst isUndefined = (value: any): boolean => value === undefined;\n\n// Cache for compiled regex patterns\nconst JSON_CONTENT_TYPE_REGEX = /application\\/json/i;\n\n// Request cache for deduplication\nconst requestCache = new Map<string, Promise<any>>();\n\nexport interface HunterOptionsType {\n  readonly headers?: Headers;\n  readonly token?: string;\n  readonly variables?: any;\n  readonly timeout?: number;\n  readonly cache?: boolean;\n}\n\nexport interface HunterQueryType {\n  readonly query: string;\n  readonly variables?: any;\n}\n\nexport interface HunterSSEOptionsType {\n  readonly headers?: Headers;\n  readonly token?: string;\n  readonly timeout?: number;\n  readonly retryInterval?: number;\n  readonly maxRetries?: number;\n}\n\nexport interface HunterSSEEventType {\n  readonly data: string;\n  readonly type: string;\n  readonly id?: string;\n  readonly retry?: number | undefined;\n}\n\nexport interface HunterSSECallbackType {\n  onMessage?: (event: HunterSSEEventType) => void;\n  onOpen?: (event: Event) => void;\n  onError?: (error: Error | Event) => void;\n  onRetry?: (attempt: number, delay: number) => void;\n}\n\nexport interface HunterSubscriptionOptionsType {\n  readonly headers?: Headers;\n  readonly token?: string;\n  readonly variables?: Record<string, unknown>;\n  readonly connectionParams?: Record<string, unknown>;\n  readonly reconnectInterval?: number;\n  readonly maxReconnectAttempts?: number;\n  readonly timeout?: number;\n}\n\nexport interface HunterSubscriptionCallbackType {\n  onNext?: (data: any) => void;\n  onError?: (error: Error | Event) => void;\n  onComplete?: () => void;\n  onReconnect?: (attempt: number) => void;\n}\n\nexport const removeSpaces = (str: string): string =>\n  str.replace(/\\s+(?=(?:[^'\"]*['\"][^'\"]*['\"])*[^'\"]*$)/gm, '');\n\nexport const queryString = (json: any): string =>\n  Object.keys(json)\n    .map(\n      (key: string) =>\n        `${encodeURIComponent(key)}=${encodeURIComponent(json[key])}`\n    )\n    .join('&');\n\n// Create a timeout promise\nconst createTimeout = (ms: number): Promise<never> =>\n  new Promise((_, reject) =>\n    setTimeout(() => reject(new Error('Request timeout')), ms)\n  );\n\n// Generate cache key for request deduplication\nconst generateCacheKey = (url: string, method: string, params?: any, options?: HunterOptionsType): string => {\n  const key = JSON.stringify({method, options, params, url});\n  return btoa(key).slice(0, 50); // Truncate to reasonable length\n};\n\n// SSE EventSource polyfill for Node.js\nconst createEventSource = (url: string, options?: HunterSSEOptionsType): EventSource => {\n  if(typeof EventSource !== 'undefined') {\n    return new EventSource(url);\n  }\n\n  // For Node.js, we'll throw an error suggesting the user install eventsource\n  throw new Error('EventSource not available in this environment. For Node.js support, install the \"eventsource\" package and import it manually.');\n};\n\n// WebSocket client for GraphQL subscriptions (graphql-ws protocol)\nclass GraphQLSubscriptionClient {\n  private ws: WebSocket | null = null;\n  private url: string;\n  private options: HunterSubscriptionOptionsType;\n  private reconnectAttempts = 0;\n  private reconnectTimer: NodeJS.Timeout | null = null;\n  private messageQueue: string[] = [];\n  private isConnecting = false;\n  private isConnected = false;\n  private subscriptions = new Map<string, HunterSubscriptionCallbackType>();\n  private messageHandlers = new Map<string, (event: MessageEvent) => void>();\n\n  constructor(url: string, options: HunterSubscriptionOptionsType = {}) {\n    this.url = url;\n    this.options = options;\n  }\n\n  private convertToWebSocketUrl(url: string): string {\n    return url.replace(/^http/, 'ws').replace(/^https/, 'wss');\n  }\n\n  private connect(): Promise<void> {\n    return new Promise((resolve, reject) => {\n      if(this.isConnecting) {\n        return;\n      }\n      this.isConnecting = true;\n\n      try {\n        const wsUrl = this.convertToWebSocketUrl(this.url);\n\n        if(typeof WebSocket === 'undefined') {\n          this.isConnecting = false;\n          reject(new Error('WebSocket not available in this environment. For Node.js support, you may need to install a WebSocket library.'));\n          return;\n        }\n\n        this.ws = new WebSocket(wsUrl, 'graphql-ws');\n\n        this.ws.onopen = () => {\n          this.isConnecting = false;\n          this.isConnected = true;\n          this.reconnectAttempts = 0;\n\n          const initMessage = {\n            type: 'connection_init',\n            payload: this.options.connectionParams || {}\n          };\n          this.send(JSON.stringify(initMessage));\n\n          while(this.messageQueue.length > 0) {\n            const message = this.messageQueue.shift();\n            if(message && this.ws?.readyState === WebSocket.OPEN) {\n              this.ws.send(message);\n            }\n          }\n\n          resolve();\n        };\n\n        this.ws.onerror = (error) => {\n          this.isConnecting = false;\n          if(!this.isConnected) {\n            reject(error);\n          }\n        };\n\n        this.ws.onclose = () => {\n          this.isConnecting = false;\n          this.isConnected = false;\n          this.handleReconnect();\n        };\n\n        this.ws.onmessage = (event: MessageEvent) => {\n          try {\n            const message = JSON.parse(event.data);\n\n            if(message.type === 'connection_ack') {\n              return;\n            }\n\n            if(message.type === 'connection_error') {\n              const error = new Error(message.payload?.message || 'Connection error');\n              this.subscriptions.forEach((callbacks) => {\n                if(callbacks.onError) {\n                  callbacks.onError(error);\n                }\n              });\n              return;\n            }\n\n            const subscriptionId = message.id;\n            const callbacks = this.subscriptions.get(subscriptionId);\n\n            if(callbacks) {\n              switch(message.type) {\n                case 'data':\n                  if(callbacks.onNext) {\n                    callbacks.onNext(message.payload?.data || message.payload);\n                  }\n                  break;\n                case 'error':\n                  if(callbacks.onError) {\n                    const error = new ApiError(\n                      Array.isArray(message.payload) ? message.payload : [message.payload],\n                      new Error('GraphQL subscription error')\n                    );\n                    callbacks.onError(error);\n                  }\n                  break;\n                case 'complete':\n                  if(callbacks.onComplete) {\n                    callbacks.onComplete();\n                  }\n                  this.subscriptions.delete(subscriptionId);\n                  const handler = this.messageHandlers.get(subscriptionId);\n                  if(handler && this.ws) {\n                    this.ws.removeEventListener('message', handler);\n                    this.messageHandlers.delete(subscriptionId);\n                  }\n                  break;\n              }\n            }\n          } catch(error) {\n            this.subscriptions.forEach((callbacks) => {\n              if(callbacks.onError) {\n                callbacks.onError(error instanceof Error ? error : new Error('Parse error'));\n              }\n            });\n          }\n        };\n      } catch(error) {\n        this.isConnecting = false;\n        reject(error);\n      }\n    });\n  }\n\n  private handleReconnect(): void {\n    const {maxReconnectAttempts = 5, reconnectInterval = 1000} = this.options;\n\n    if(this.reconnectAttempts < maxReconnectAttempts && this.subscriptions.size > 0) {\n      this.reconnectAttempts++;\n\n      this.subscriptions.forEach((callbacks) => {\n        if(callbacks.onReconnect) {\n          callbacks.onReconnect(this.reconnectAttempts);\n        }\n      });\n\n      this.reconnectTimer = setTimeout(() => {\n        this.connect().catch(() => {\n        });\n      }, reconnectInterval);\n    } else if(this.subscriptions.size > 0) {\n      const error = new Error('WebSocket reconnection failed after max attempts');\n      this.subscriptions.forEach((callbacks) => {\n        if(callbacks.onError) {\n          callbacks.onError(error);\n        }\n      });\n    }\n  }\n\n  private send(message: string): void {\n    if(this.ws?.readyState === WebSocket.OPEN) {\n      this.ws.send(message);\n    } else {\n      this.messageQueue.push(message);\n      if(!this.isConnecting && !this.isConnected) {\n        this.connect().catch(() => {\n        });\n      }\n    }\n  }\n\n  subscribe(\n    query: string,\n    variables: Record<string, unknown> | undefined,\n    callbacks: HunterSubscriptionCallbackType\n  ): () => void {\n    const subscriptionId = `sub_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;\n\n    this.subscriptions.set(subscriptionId, callbacks);\n\n    const startMessage = {\n      id: subscriptionId,\n      type: 'start',\n      payload: {\n        query,\n        variables: variables || {}\n      }\n    };\n\n    const ensureConnection = (): void => {\n      if(!this.isConnected && !this.isConnecting) {\n        this.connect().then(() => {\n          this.send(JSON.stringify(startMessage));\n        }).catch((error) => {\n          if(callbacks.onError) {\n            callbacks.onError(error);\n          }\n        });\n      } else if(this.isConnected) {\n        this.send(JSON.stringify(startMessage));\n      }\n    };\n\n    ensureConnection();\n\n    return () => {\n      const stopMessage = {\n        id: subscriptionId,\n        type: 'stop'\n      };\n      this.send(JSON.stringify(stopMessage));\n      this.subscriptions.delete(subscriptionId);\n      const handler = this.messageHandlers.get(subscriptionId);\n      if(handler && this.ws) {\n        this.ws.removeEventListener('message', handler);\n        this.messageHandlers.delete(subscriptionId);\n      }\n    };\n  }\n\n  close(): void {\n    if(this.reconnectTimer) {\n      clearTimeout(this.reconnectTimer);\n      this.reconnectTimer = null;\n    }\n    if(this.ws) {\n      this.ws.close();\n      this.ws = null;\n    }\n    this.messageQueue = [];\n    this.subscriptions.clear();\n    this.messageHandlers.clear();\n    this.isConnected = false;\n    this.isConnecting = false;\n  }\n}\n\n// Subscription client cache\nconst subscriptionClients = new Map<string, GraphQLSubscriptionClient>();\n\n// AJAX\nexport const ajax = (\n  url: string,\n  method: string,\n  params?,\n  options: HunterOptionsType = {}\n): Promise<any> => {\n  const {headers, token, timeout = 30000, cache = false} = options;\n\n  let formatUrl: string = (url || '').trim();\n  const formatToken: string = (token || '').trim();\n  const formatHeaders: Headers = headers || new Headers();\n\n  // Method\n  const formatMethod: string = (method || 'GET').toUpperCase();\n  let formatParams;\n\n  // Parameters\n  if(params && formatMethod === 'GET') {\n    formatUrl = `${formatUrl}?${queryString(params)}`;\n    formatParams = null;\n  } else if(params) {\n    formatHeaders.set('Accept', 'application/json');\n    formatHeaders.set('Content-Type', 'application/json');\n    formatParams = JSON.stringify(params);\n  } else {\n    formatParams = params;\n  }\n\n  // Authentication token\n  if(!isEmpty(formatToken)) {\n    formatHeaders.set('Authorization', `Bearer ${formatToken}`);\n  }\n\n  // Check cache for GET requests\n  if(cache && formatMethod === 'GET') {\n    const cacheKey = generateCacheKey(formatUrl, formatMethod, params, options);\n    const cached = requestCache.get(cacheKey);\n    if(cached) {\n      return cached;\n    }\n  }\n\n  // Create the request promise\n  const requestPromise = fetch(formatUrl, {\n    body: formatParams,\n    headers: formatHeaders,\n    method: formatMethod\n  })\n    .then((response: Response) => {\n      // Check if response is json using cached regex\n      const isResponseJson = JSON_CONTENT_TYPE_REGEX.test(\n        response.headers.get('Content-Type') || ''\n      );\n\n      if(isResponseJson) {\n        return response.json();\n      }\n\n      return response.text();\n    })\n    .then((results) => results) // Simplified - no need for redundant check\n    .catch((error) => {\n      if((error || {}).message === 'only absolute urls are supported') {\n        return Promise.reject(\n          new ApiError([{message: 'invalid_url'}], error)\n        );\n      }\n\n      return Promise.reject(\n        new ApiError([{message: 'network_error'}], error)\n      );\n    });\n\n  // Add timeout if specified\n  const finalPromise = timeout > 0\n    ? Promise.race([requestPromise, createTimeout(timeout)])\n    : requestPromise;\n\n  // Cache the promise for GET requests\n  if(cache && formatMethod === 'GET') {\n    const cacheKey = generateCacheKey(formatUrl, formatMethod, params, options);\n    requestCache.set(cacheKey, finalPromise);\n\n    // Clean up cache after 5 minutes\n    setTimeout(() => requestCache.delete(cacheKey), 300000);\n  }\n\n  return finalPromise;\n};\n\nexport const get = (\n  url: string,\n  params?,\n  options?: HunterOptionsType\n): Promise<any> => ajax(url, 'GET', params, options);\n\nexport const post = (\n  url: string,\n  params?,\n  options?: HunterOptionsType\n): Promise<any> => ajax(url, 'POST', params, options);\n\nexport const put = (\n  url: string,\n  params?,\n  options?: HunterOptionsType\n): Promise<any> => ajax(url, 'PUT', params, options);\n\nexport const del = (\n  url: string,\n  params?,\n  options?: HunterOptionsType\n): Promise<any> => ajax(url, 'DELETE', params, options);\n\n// Optimized toGql function\nexport const toGql = (obj: any): string => {\n  if(isString(obj)) {\n    return JSON.stringify(obj);\n  } else if(isPlainObject(obj)) {\n    // Filter out undefined and null values in one pass\n    const gqlProps: string[] = [];\n\n    for(const key in obj) {\n      if(obj.hasOwnProperty(key)) {\n        const item = obj[key];\n\n        // Skip undefined and null values\n        if(isUndefined(item) || isNull(item)) {\n          continue;\n        }\n\n        if(isPlainObject(item)) {\n          gqlProps.push(`${key}: ${toGql(item)}`);\n        } else if(isArray(item)) {\n          const list = item.map((listItem) => toGql(listItem));\n          gqlProps.push(`${key}: [${list.join(', ')}]`);\n        } else {\n          const val = JSON.stringify(item);\n          if(val) {\n            gqlProps.push(`${key}: ${val}`);\n          }\n        }\n      }\n    }\n\n    const values = gqlProps.join(', ');\n    return values === '' ? '\"\"' : `{${gqlProps.join(', ')}}`;\n  } else if(isArray(obj)) {\n    return `[${obj.map((objItem) => toGql(objItem)).join(', ')}]`;\n  }\n\n  return String(obj);\n};\n\nexport const graphqlQuery = (\n  url: string,\n  query: HunterQueryType | HunterQueryType[],\n  options: HunterOptionsType = {}\n): Promise<any> => {\n  const {headers, token, timeout = 30000} = options;\n  const formatUrl: string = url ? url.trim() : '';\n  const formatToken: string = (token || '').trim();\n  const formatHeaders: Headers = headers || new Headers({'Content-Type': 'application/json'});\n\n  if(!isEmpty(formatToken)) {\n    formatHeaders.set('Authorization', `Bearer ${formatToken}`);\n  }\n\n  const requestPromise = fetch(formatUrl, {\n    body: JSON.stringify(query),\n    headers: formatHeaders,\n    method: 'post'\n  })\n    .then((response: Response) => {\n      const isJson: boolean = JSON_CONTENT_TYPE_REGEX.test(\n        response.headers.get('Content-Type') || ''\n      );\n\n      if(isJson && response.body) {\n        return response.json();\n      }\n\n      return null;\n    })\n    .catch((error) => {\n      if((error || {}).message === 'only absolute urls are supported') {\n        return Promise.reject(\n          new ApiError([{message: 'invalid_url'}], error)\n        );\n      }\n\n      return Promise.reject(\n        new ApiError([{message: 'network_error'}], error)\n      );\n    })\n    .then((json) => {\n      if(!json || json.errors) {\n        if(!json) {\n          return Promise.reject(\n            new ApiError([{message: 'api_error'}], new Error())\n          );\n        } else if(\n          (json.errors || []).some(\n            (error) => error.message === 'Must provide query string.'\n          )\n        ) {\n          return Promise.reject(\n            new ApiError([{message: 'required_query'}], new Error())\n          );\n        }\n\n        return json.errors\n          ? Promise.reject(new ApiError(json.errors, new Error()))\n          : {};\n      }\n\n      return json.data || {};\n    })\n    .catch((error: ApiError) =>\n      // Simplified error handling - no need to create new error if source exists\n      Promise.reject(error.source ? error : new ApiError([{message: 'network_error'}], error))\n    );\n\n  // Add timeout if specified\n  return timeout > 0\n    ? Promise.race([requestPromise, createTimeout(timeout)])\n    : requestPromise;\n};\n\n// Add query and mutation functions for better API consistency\nexport const query = (\n  url: string,\n  body: string,\n  options: HunterOptionsType = {}\n): Promise<any> => graphqlQuery(url, {query: body}, options);\n\nexport const mutation = (\n  url: string,\n  body: string,\n  options: HunterOptionsType = {}\n): Promise<any> => graphqlQuery(url, {query: body}, options);\n\n// GraphQL Subscriptions\nexport const subscribe = (\n  url: string,\n  query: string,\n  callbacks: HunterSubscriptionCallbackType,\n  options: HunterSubscriptionOptionsType = {}\n): (() => void) => {\n  const {token, variables, connectionParams, headers} = options;\n  const formatUrl: string = (url || '').trim();\n  const formatToken: string = (token || '').trim();\n\n  if(!formatUrl) {\n    if(callbacks.onError) {\n      callbacks.onError(new Error('Subscription URL is required'));\n    }\n    return () => {};\n  }\n\n  let client = subscriptionClients.get(formatUrl);\n  if(!client) {\n    const clientOptions: HunterSubscriptionOptionsType = {\n      ...options,\n      connectionParams: {\n        ...connectionParams,\n        ...(formatToken ? {authorization: `Bearer ${formatToken}`} : {})\n      }\n    };\n    client = new GraphQLSubscriptionClient(formatUrl, clientOptions);\n    subscriptionClients.set(formatUrl, client);\n  }\n\n  return client.subscribe(query, variables, callbacks);\n};\n\n// SSE Support\nexport const subscribeSSE = (\n  url: string,\n  callbacks: HunterSSECallbackType,\n  options: HunterSSEOptionsType = {}\n): (() => void) => {\n  const {headers, token, timeout = 30000, retryInterval = 1000, maxRetries = 5} = options;\n  const formatUrl: string = (url || '').trim();\n  const formatToken: string = (token || '').trim();\n  const formatHeaders: Headers = headers || new Headers();\n\n  // Add authorization header if token provided\n  if(!isEmpty(formatToken)) {\n    formatHeaders.set('Authorization', `Bearer ${formatToken}`);\n  }\n\n  let retryCount = 0;\n  let eventSource: EventSource | null = null;\n  let timeoutId: NodeJS.Timeout | null = null;\n\n  const connect = (): void => {\n    try {\n      eventSource = createEventSource(formatUrl, {headers: formatHeaders});\n\n      // Set up timeout\n      if(timeout > 0) {\n        timeoutId = setTimeout(() => {\n          if(eventSource) {\n            eventSource.close();\n            if(callbacks.onError) {\n              callbacks.onError(new Error('SSE connection timeout'));\n            }\n          }\n        }, timeout);\n      }\n\n      // Event handlers\n      eventSource.onopen = (event) => {\n        if(timeoutId) {\n          clearTimeout(timeoutId);\n          timeoutId = null;\n        }\n        retryCount = 0; // Reset retry count on successful connection\n        if(callbacks.onOpen) {\n          callbacks.onOpen(event);\n        }\n      };\n\n      eventSource.onmessage = (event) => {\n        if(callbacks.onMessage) {\n          const sseEvent: HunterSSEEventType = {\n            data: event.data,\n            id: event.lastEventId,\n            retry: event.data.includes('retry:') ? parseInt(event.data.split('retry:')[1]) : undefined,\n            type: event.type\n          };\n          callbacks.onMessage(sseEvent);\n        }\n      };\n\n      eventSource.onerror = (event) => {\n        if(timeoutId) {\n          clearTimeout(timeoutId);\n          timeoutId = null;\n        }\n\n        if(eventSource && eventSource.readyState === EventSource.CLOSED) {\n          // Connection closed, attempt retry if within limits\n          if(retryCount < maxRetries) {\n            retryCount++;\n            if(callbacks.onRetry) {\n              callbacks.onRetry(retryCount, retryInterval);\n            }\n            setTimeout(connect, retryInterval);\n          } else {\n            if(callbacks.onError) {\n              callbacks.onError(new Error('SSE connection failed after max retries'));\n            }\n          }\n        } else {\n          if(callbacks.onError) {\n            callbacks.onError(event);\n          }\n        }\n      };\n    } catch(error) {\n      if(callbacks.onError) {\n        callbacks.onError(error instanceof Error ? error : new Error('Failed to create SSE connection'));\n      }\n    }\n  };\n\n  // Start the connection\n  connect();\n\n  // Return cleanup function\n  return () => {\n    if(timeoutId) {\n      clearTimeout(timeoutId);\n      timeoutId = null;\n    }\n    if(eventSource) {\n      eventSource.close();\n      eventSource = null;\n    }\n  };\n};\n\nexport {ApiError} from './errors/ApiError.js';\n"],"names":["ApiError","isArray","value","Array","isString","isPlainObject","isEmpty","undefined","isNull","isUndefined","JSON_CONTENT_TYPE_REGEX","requestCache","Map","removeSpaces","str","replace","queryString","json","Object","keys","map","key","encodeURIComponent","join","createTimeout","ms","Promise","_","reject","setTimeout","Error","generateCacheKey","url","method","params","options","JSON","stringify","btoa","slice","createEventSource","EventSource","GraphQLSubscriptionClient","ws","reconnectAttempts","reconnectTimer","messageQueue","isConnecting","isConnected","subscriptions","messageHandlers","convertToWebSocketUrl","connect","resolve","wsUrl","WebSocket","onopen","initMessage","type","payload","connectionParams","send","length","message","shift","readyState","OPEN","onerror","error","onclose","handleReconnect","onmessage","event","parse","data","forEach","callbacks","onError","subscriptionId","id","get","onNext","onComplete","delete","handler","removeEventListener","maxReconnectAttempts","reconnectInterval","size","onReconnect","catch","push","subscribe","query","variables","Date","now","Math","random","toString","substr","set","startMessage","ensureConnection","then","stopMessage","close","clearTimeout","clear","subscriptionClients","ajax","headers","token","timeout","cache","formatUrl","trim","formatToken","formatHeaders","Headers","formatMethod","toUpperCase","formatParams","cacheKey","cached","requestPromise","fetch","body","response","isResponseJson","test","text","results","finalPromise","race","post","put","del","toGql","obj","gqlProps","hasOwnProperty","item","list","listItem","val","values","objItem","String","graphqlQuery","isJson","errors","some","source","mutation","client","clientOptions","authorization","subscribeSSE","retryInterval","maxRetries","retryCount","eventSource","timeoutId","onOpen","onMessage","sseEvent","lastEventId","retry","includes","parseInt","split","CLOSED","onRetry"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nlabs/rip-hunter",
-  "version": "3.0.2",
+  "version": "3.1.0",
   "description": "JS utilities for AJAX and GraphQL",
   "license": "MIT",
   "type": "module",
@@ -64,14 +64,24 @@
     "benchmark": "node --experimental-modules ./benchmark.js"
   },
   "optionalDependencies": {
-    "eventsource": "^2.0.2"
+    "eventsource": "^4.1.0"
   },
   "devDependencies": {
-    "@jest/globals": "30.0.4",
-    "@nlabs/lex": "1.47.2",
+    "@jest/globals": "30.2.0",
     "@nlabs/fetch-mock": "1.0.2",
+    "@nlabs/lex": "1.53.2",
     "@types/jest": "30.0.0",
-    "@types/node": "24.0.12",
-    "typescript": "5.8.3"
+    "@types/node": "25.0.8",
+    "jest-websocket-mock": "^2.5.0",
+    "typescript": "5.9.3"
+  },
+  "overrides": {
+    "cross-spawn": "^7.0.6",
+    "got": "^14.6.6",
+    "http-cache-semantics": "^4.2.0",
+    "http-proxy-middleware": "^3.0.5",
+    "postcss": "^8.5.6",
+    "semver-regex": "^4.0.5",
+    "tmp": "^0.2.5"
   }
 }