juxscript 1.0.132 → 1.1.2

package/lib/utils/{fetch.js → fetch.ts}

@@ -1,9 +1,9 @@
 /**
  * Jux Fetch Utility
- *
+ * 
  * A lightweight fetch wrapper with sensible defaults, error handling, and method chaining.
  * Includes configuration helpers for juxconfig.js integration.
- *
+ * 
  * Usage:
  *   // Configure once (optional)
  *   jux.fetch.config({
@@ -13,10 +13,10 @@
  *     log: 'errors',
  *     onUnauthorized: () => window.location.href = '/login'
  *   });
- *
+ *   
  *   // Simple GET
  *   const { data, error } = await jux.fetch('/users').send();
- *
+ *   
  *   // Method chaining
  *   const { data, error } = await jux.fetch('/users')
  *     .method('POST')
@@ -25,18 +25,55 @@
  *     .timeout(5000)
  *     .log(true)
  *     .send();
- *
+ *   
  *   // With juxconfig services
  *   const { data } = await jux.fetch('/users')
  *     .baseUrl(jux.fetch.getServiceUrl('database'))
  *     .send();
- *
+ *   
  *   // Service client helper
  *   const db = jux.fetch.serviceClient('database');
  *   const { data } = await db.fetch('/users').send();
  */
+
+export type LogLevel = boolean | 'errors';
+
+export interface FetchConfig {
+    baseUrl?: string;
+    credentials?: RequestCredentials;
+    headers?: Record<string, string>;
+    timeout?: number;
+    log?: LogLevel;
+    onUnauthorized?: () => void;
+    onError?: (error: FetchError) => void;
+}
+
+export interface FetchOptions extends Omit<RequestInit, 'body'> {
+    params?: Record<string, any>;
+    body?: any;
+    timeout?: number;
+    log?: LogLevel;
+    onUnauthorized?: () => void;
+    onError?: (error: FetchError) => void;
+    parseResponse?: boolean;
+}
+
+export interface FetchError {
+    message: string;
+    status?: number;
+    statusText?: string;
+    data?: any;
+}
+
+export interface FetchResult<T = any> {
+    data: T | null;
+    error: FetchError | null;
+    status: number;
+    response: Response;
+}
+
 // Global configuration
-let globalConfig = {
+let globalConfig: FetchConfig = {
     credentials: 'same-origin',
     headers: {
         'Content-Type': 'application/json'
@@ -44,10 +81,11 @@ let globalConfig = {
     timeout: 30000,
     log: false
 };
+
 /**
  * Configure global fetch defaults
  */
-export function configureFetch(config) {
+export function configureFetch(config: FetchConfig): void {
     globalConfig = {
         ...globalConfig,
         ...config,
@@ -57,64 +95,86 @@ export function configureFetch(config) {
         }
     };
 }
+
 /**
  * Build URL with query parameters
  */
-function buildUrl(url, params) {
+function buildUrl(url: string, params?: Record<string, any>): string {
     if (!params || Object.keys(params).length === 0) {
         return url;
     }
+
     const searchParams = new URLSearchParams();
     Object.entries(params).forEach(([key, value]) => {
         if (value !== undefined && value !== null) {
             searchParams.append(key, String(value));
         }
     });
+
     const queryString = searchParams.toString();
-    if (!queryString)
-        return url;
+    if (!queryString) return url;
+
     return url.includes('?')
         ? `${url}&${queryString}`
         : `${url}?${queryString}`;
 }
+
 /**
  * Main fetch function
  */
-async function executeFetch(url, options = {}) {
-    const { params, body, timeout = globalConfig.timeout, log = globalConfig.log, onUnauthorized = globalConfig.onUnauthorized, onError = globalConfig.onError, parseResponse = true, headers = {}, ...fetchOptions } = options;
+async function executeFetch<T = any>(
+    url: string,
+    options: FetchOptions = {}
+): Promise<FetchResult<T>> {
+    const {
+        params,
+        body,
+        timeout = globalConfig.timeout,
+        log = globalConfig.log,
+        onUnauthorized = globalConfig.onUnauthorized,
+        onError = globalConfig.onError,
+        parseResponse = true,
+        headers = {},
+        ...fetchOptions
+    } = options;
+
     // Build full URL
     let fullUrl = url;
+
     // Add base URL if configured and URL is relative
     if (globalConfig.baseUrl && !url.startsWith('http://') && !url.startsWith('https://')) {
         fullUrl = `${globalConfig.baseUrl}${url.startsWith('/') ? url : `/${url}`}`;
     }
+
     // Add query params
     fullUrl = buildUrl(fullUrl, params);
+
     // Merge headers
     const mergedHeaders = {
         ...globalConfig.headers,
         ...headers
     };
+
     // Prepare request init
-    const requestInit = {
+    const requestInit: RequestInit = {
         ...fetchOptions,
         headers: mergedHeaders,
         credentials: options.credentials ?? globalConfig.credentials
     };
+
     // Stringify body if it's an object
     if (body !== undefined) {
         if (body instanceof FormData) {
             requestInit.body = body;
             // Remove Content-Type header for FormData (browser sets it with boundary)
-            delete requestInit.headers['Content-Type'];
-        }
-        else if (typeof body === 'object') {
+            delete (requestInit.headers as Record<string, string>)['Content-Type'];
+        } else if (typeof body === 'object') {
             requestInit.body = JSON.stringify(body);
-        }
-        else {
+        } else {
             requestInit.body = body;
         }
     }
+
     // Log request
     if (log === true) {
         console.log(`[JUX Fetch] ${requestInit.method || 'GET'} ${fullUrl}`, {
@@ -123,66 +183,73 @@ async function executeFetch(url, options = {}) {
             params
         });
     }
+
     // Setup timeout
     const controller = new AbortController();
     const timeoutId = timeout ? setTimeout(() => controller.abort(), timeout) : null;
+
     if (!requestInit.signal) {
         requestInit.signal = controller.signal;
     }
+
     try {
         const response = await fetch(fullUrl, requestInit);
-        if (timeoutId)
-            clearTimeout(timeoutId);
+
+        if (timeoutId) clearTimeout(timeoutId);
+
         // Handle unauthorized
         if (response.status === 401 || response.status === 403) {
             if (onUnauthorized) {
                 onUnauthorized();
             }
         }
+
         // Parse response
-        let data = null;
-        let errorData = null;
+        let data: T | null = null;
+        let errorData: any = null;
+
         if (parseResponse) {
             const contentType = response.headers.get('content-type');
+
             if (contentType?.includes('application/json')) {
                 try {
                     const json = await response.json();
                     if (response.ok) {
                         data = json;
-                    }
-                    else {
+                    } else {
                         errorData = json;
                     }
-                }
-                catch (e) {
+                } catch (e) {
                     // JSON parse error
                 }
-            }
-            else if (response.ok) {
+            } else if (response.ok) {
                 // Non-JSON response, try to get text
                 try {
-                    data = (await response.text());
-                }
-                catch (e) {
+                    data = (await response.text()) as any;
+                } catch (e) {
                     // Ignore text parse errors
                 }
             }
         }
+
         // Check if request was successful
         if (!response.ok) {
-            const error = {
+            const error: FetchError = {
                 message: errorData?.message || errorData?.error || response.statusText || 'Request failed',
                 status: response.status,
                 statusText: response.statusText,
                 data: errorData
             };
+
             // Log error
             if (log === true || log === 'errors') {
                 console.error(`[JUX Fetch Error] ${requestInit.method || 'GET'} ${fullUrl}`, error);
             }
+
             if (onError) {
                 onError(error);
             }
+
             return {
                 data: null,
                 error,
@@ -190,6 +257,7 @@ async function executeFetch(url, options = {}) {
                 response
             };
         }
+
         // Log success
         if (log === true) {
             console.log(`[JUX Fetch Success] ${requestInit.method || 'GET'} ${fullUrl}`, {
@@ -197,169 +265,216 @@ async function executeFetch(url, options = {}) {
                 data
             });
         }
+
         return {
             data,
             error: null,
             status: response.status,
             response
         };
-    }
-    catch (err) {
-        if (timeoutId)
-            clearTimeout(timeoutId);
-        const error = {
+
+    } catch (err: any) {
+        if (timeoutId) clearTimeout(timeoutId);
+
+        const error: FetchError = {
             message: err.name === 'AbortError'
                 ? 'Request timeout'
                 : err.message || 'Network error',
             status: 0
         };
+
         // Log error
         if (log === true || log === 'errors') {
             console.error(`[JUX Fetch Error] ${requestInit.method || 'GET'} ${fullUrl}`, error);
         }
+
         if (onError) {
             onError(error);
         }
+
         return {
             data: null,
             error,
             status: 0,
-            response: null
+            response: null as any
         };
     }
 }
+
 /**
  * FetchBuilder class for method chaining
  */
-class FetchBuilder {
-    constructor(url, options = {}) {
-        this.options = {};
+class FetchBuilder<T = any> {
+    public url: string;
+    public options: FetchOptions = {};
+
+    constructor(url: string, options: FetchOptions = {}) {
         this.url = url;
         this.options = options;
     }
-    method(value) {
+
+    method(value: string): this {
         this.options.method = value;
         return this;
     }
-    body(value) {
+
+    body(value: any): this {
         this.options.body = value;
         return this;
     }
-    params(value) {
+
+    params(value: Record<string, any>): this {
         this.options.params = value;
         return this;
     }
-    headers(value) {
+
+    headers(value: Record<string, string>): this {
         this.options.headers = { ...this.options.headers, ...value };
         return this;
     }
-    header(key, value) {
+
+    header(key: string, value: string): this {
         this.options.headers = { ...this.options.headers, [key]: value };
         return this;
     }
-    timeout(value) {
+
+    timeout(value: number): this {
         this.options.timeout = value;
         return this;
     }
-    credentials(value) {
+
+    credentials(value: RequestCredentials): this {
         this.options.credentials = value;
         return this;
     }
-    log(value) {
+
+    log(value: LogLevel): this {
         this.options.log = value;
         return this;
     }
-    parseResponse(value) {
+
+    parseResponse(value: boolean): this {
         this.options.parseResponse = value;
         return this;
     }
-    onUnauthorized(callback) {
+
+    onUnauthorized(callback: () => void): this {
         this.options.onUnauthorized = callback;
         return this;
     }
-    onError(callback) {
+
+    onError(callback: (error: FetchError) => void): this {
         this.options.onError = callback;
         return this;
     }
+
     /**
      * Execute the fetch request
      */
-    send() {
-        return executeFetch(this.url, this.options);
+    send(): Promise<FetchResult<T>> {
+        return executeFetch<T>(this.url, this.options);
     }
+
     /**
      * Alias for send()
      */
-    fetch() {
+    fetch(): Promise<FetchResult<T>> {
         return this.send();
     }
+
     /**
      * Make the builder thenable (Promise-like) so it can be awaited directly
      * This allows: await jux.fetch('/users') without needing .send()
      */
-    then(onfulfilled, onrejected) {
+    then<TResult1 = FetchResult<T>, TResult2 = never>(
+        onfulfilled?: ((value: FetchResult<T>) => TResult1 | PromiseLike<TResult1>) | null,
+        onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null
+    ): Promise<TResult1 | TResult2> {
         return this.send().then(onfulfilled, onrejected);
     }
+
     /**
      * Make the builder catchable for Promise.catch()
      */
-    catch(onrejected) {
+    catch<TResult = never>(
+        onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null
+    ): Promise<FetchResult<T> | TResult> {
         return this.send().catch(onrejected);
     }
+
     /**
      * Make the builder finally-able for Promise.finally()
      */
-    finally(onfinally) {
+    finally(onfinally?: (() => void) | null): Promise<FetchResult<T>> {
         return this.send().finally(onfinally);
     }
 }
+
 /**
  * Create a fetch builder
  */
-export function juxFetch(url, options = {}) {
-    return new FetchBuilder(url, options);
+export function juxFetch<T = any>(url: string, options: FetchOptions = {}): FetchBuilder<T> {
+    return new FetchBuilder<T>(url, options);
 }
+
 /**
  * Convenience methods for common HTTP verbs
  */
 export const fetchHelpers = {
-    get: (url, options) => new FetchBuilder(url, { ...options, method: 'GET' }),
-    post: (url, body, options) => new FetchBuilder(url, { ...options, method: 'POST', body }),
-    put: (url, body, options) => new FetchBuilder(url, { ...options, method: 'PUT', body }),
-    patch: (url, body, options) => new FetchBuilder(url, { ...options, method: 'PATCH', body }),
-    delete: (url, options) => new FetchBuilder(url, { ...options, method: 'DELETE' })
+    get: <T = any>(url: string, options?: Omit<FetchOptions, 'method'>) =>
+        new FetchBuilder<T>(url, { ...options, method: 'GET' }),
+
+    post: <T = any>(url: string, body?: any, options?: Omit<FetchOptions, 'method' | 'body'>) =>
+        new FetchBuilder<T>(url, { ...options, method: 'POST', body }),
+
+    put: <T = any>(url: string, body?: any, options?: Omit<FetchOptions, 'method' | 'body'>) =>
+        new FetchBuilder<T>(url, { ...options, method: 'PUT', body }),
+
+    patch: <T = any>(url: string, body?: any, options?: Omit<FetchOptions, 'method' | 'body'>) =>
+        new FetchBuilder<T>(url, { ...options, method: 'PATCH', body }),
+
+    delete: <T = any>(url: string, options?: Omit<FetchOptions, 'method'>) =>
+        new FetchBuilder<T>(url, { ...options, method: 'DELETE' })
 };
+
 /**
  * Fetch multiple URLs in parallel
  */
-export async function fetchAll(urls, options) {
-    return Promise.all(urls.map(url => executeFetch(url, options)));
+export async function fetchAll<T = any>(
+    urls: string[],
+    options?: FetchOptions
+): Promise<FetchResult<T>[]> {
+    return Promise.all(urls.map(url => executeFetch<T>(url, options)));
 }
+
 /**
  * Get a service URL from window.juxConfig
  */
-export function getServiceUrl(serviceName) {
-    if (typeof window === 'undefined')
-        return null;
-    const juxConfig = window.juxConfig;
-    if (!juxConfig?.services)
-        return null;
+export function getServiceUrl(serviceName: string): string | null {
+    if (typeof window === 'undefined') return null;
+
+    const juxConfig = (window as any).juxConfig;
+    if (!juxConfig?.services) return null;
+
     return juxConfig.services[serviceName] || null;
 }
+
 /**
  * Create a fetch instance preconfigured for a specific service
- *
+ * 
  * Usage:
  *   const api = jux.fetch.serviceClient('database');
  *   const { data } = await api.fetch('/users').send();
  */
-export function serviceClient(serviceName) {
+export function serviceClient(serviceName: string) {
     const baseUrl = getServiceUrl(serviceName);
+
     if (!baseUrl) {
         console.warn(`[JUX Fetch] Service '${serviceName}' not found in juxConfig.services`);
     }
+
     return {
-        fetch: (url, options) => {
+        fetch: (url: string, options?: any) => {
             return juxFetch(url, {
                 ...options,
                 baseUrl: baseUrl || undefined
@@ -368,10 +483,11 @@ export function serviceClient(serviceName) {
         baseUrl
     };
 }
+
 /**
  * Setup fetch from juxconfig
  * Call this in your bootstrap function
- *
+ * 
  * Usage:
  *   export default {
  *     bootstrap: [
@@ -386,36 +502,46 @@ export async function setupConfig() {
         console.warn('[JUX Fetch] setupConfig() called outside browser environment');
         return;
     }
-    const juxConfig = window.juxConfig;
+
+    const juxConfig = (window as any).juxConfig;
+
     if (!juxConfig) {
         console.warn('[JUX Fetch] No juxConfig found on window. Make sure your juxconfig.js is loaded.');
         return;
     }
+
     const services = juxConfig.services || {};
+
     if (Object.keys(services).length === 0) {
         console.log('[JUX Fetch] No services configured in juxConfig');
         return;
     }
+
     // Configure fetch with common defaults
-    const fetchConfig = {
+    const fetchConfig: FetchConfig = {
         timeout: juxConfig.fetchTimeout || 30000,
         log: juxConfig.fetchLog || false,
         credentials: 'include'
     };
+
     // Add service-specific handlers
     if (services.auth) {
         fetchConfig.onUnauthorized = () => {
             console.warn('[JUX Fetch] Unauthorized - consider redirecting to login');
         };
     }
+
     configureFetch(fetchConfig);
+
     // Log configured services
     console.log('[JUX Fetch] Configured with services:', Object.keys(services));
+
     return {
         services,
         getServiceUrl
     };
 }
+
 // Export combined API
 export const fetchAPI = Object.assign(juxFetch, {
     config: configureFetch,
@@ -425,4 +551,3 @@ export const fetchAPI = Object.assign(juxFetch, {
     ...fetchHelpers,
     all: fetchAll
 });
-//# sourceMappingURL=fetch.js.map