juxscript 1.1.244 → 1.1.246

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

@@ -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,55 +25,18 @@
  *     .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: FetchConfig = {
+let globalConfig = {
     credentials: 'same-origin',
     headers: {
         'Content-Type': 'application/json'
@@ -81,11 +44,10 @@ let globalConfig: FetchConfig = {
     timeout: 30000,
     log: false
 };
-
 /**
  * Configure global fetch defaults
  */
-export function configureFetch(config: FetchConfig): void {
+export function configureFetch(config) {
     globalConfig = {
         ...globalConfig,
         ...config,
@@ -95,86 +57,64 @@ export function configureFetch(config: FetchConfig): void {
         }
     };
 }
-
 /**
  * Build URL with query parameters
  */
-function buildUrl(url: string, params?: Record<string, any>): string {
+function buildUrl(url, params) {
     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<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;
-
+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;
     // 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: RequestInit = {
+    const 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 as Record<string, string>)['Content-Type'];
-        } else if (typeof body === 'object') {
+            delete requestInit.headers['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}`, {
@@ -183,73 +123,66 @@ async function executeFetch<T = any>(
             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: T | null = null;
-        let errorData: any = null;
-
+        let data = null;
+        let errorData = 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()) as any;
-                } catch (e) {
+                    data = (await response.text());
+                }
+                catch (e) {
                     // Ignore text parse errors
                 }
             }
         }
-
         // Check if request was successful
         if (!response.ok) {
-            const error: FetchError = {
+            const error = {
                 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,
@@ -257,7 +190,6 @@ async function executeFetch<T = any>(
                 response
             };
         }
-
         // Log success
         if (log === true) {
             console.log(`[JUX Fetch Success] ${requestInit.method || 'GET'} ${fullUrl}`, {
@@ -265,216 +197,169 @@ async function executeFetch<T = any>(
                 data
             });
         }
-
         return {
             data,
             error: null,
             status: response.status,
             response
         };
-
-    } catch (err: any) {
-        if (timeoutId) clearTimeout(timeoutId);
-
-        const error: FetchError = {
+    }
+    catch (err) {
+        if (timeoutId)
+            clearTimeout(timeoutId);
+        const error = {
             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 as any
+            response: null
         };
     }
 }
-
 /**
  * FetchBuilder class for method chaining
  */
-class FetchBuilder<T = any> {
-    public url: string;
-    public options: FetchOptions = {};
-
-    constructor(url: string, options: FetchOptions = {}) {
+class FetchBuilder {
+    constructor(url, options = {}) {
+        this.options = {};
         this.url = url;
         this.options = options;
     }
-
-    method(value: string): this {
+    method(value) {
         this.options.method = value;
         return this;
     }
-
-    body(value: any): this {
+    body(value) {
         this.options.body = value;
         return this;
     }
-
-    params(value: Record<string, any>): this {
+    params(value) {
         this.options.params = value;
         return this;
     }
-
-    headers(value: Record<string, string>): this {
+    headers(value) {
         this.options.headers = { ...this.options.headers, ...value };
         return this;
     }
-
-    header(key: string, value: string): this {
+    header(key, value) {
         this.options.headers = { ...this.options.headers, [key]: value };
         return this;
     }
-
-    timeout(value: number): this {
+    timeout(value) {
         this.options.timeout = value;
         return this;
     }
-
-    credentials(value: RequestCredentials): this {
+    credentials(value) {
         this.options.credentials = value;
         return this;
     }
-
-    log(value: LogLevel): this {
+    log(value) {
         this.options.log = value;
         return this;
     }
-
-    parseResponse(value: boolean): this {
+    parseResponse(value) {
         this.options.parseResponse = value;
         return this;
     }
-
-    onUnauthorized(callback: () => void): this {
+    onUnauthorized(callback) {
         this.options.onUnauthorized = callback;
         return this;
     }
-
-    onError(callback: (error: FetchError) => void): this {
+    onError(callback) {
         this.options.onError = callback;
         return this;
     }
-
     /**
      * Execute the fetch request
      */
-    send(): Promise<FetchResult<T>> {
-        return executeFetch<T>(this.url, this.options);
+    send() {
+        return executeFetch(this.url, this.options);
     }
-
     /**
      * Alias for send()
      */
-    fetch(): Promise<FetchResult<T>> {
+    fetch() {
         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<TResult1 = FetchResult<T>, TResult2 = never>(
-        onfulfilled?: ((value: FetchResult<T>) => TResult1 | PromiseLike<TResult1>) | null,
-        onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null
-    ): Promise<TResult1 | TResult2> {
+    then(onfulfilled, onrejected) {
         return this.send().then(onfulfilled, onrejected);
     }
-
     /**
      * Make the builder catchable for Promise.catch()
      */
-    catch<TResult = never>(
-        onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null
-    ): Promise<FetchResult<T> | TResult> {
+    catch(onrejected) {
         return this.send().catch(onrejected);
     }
-
     /**
      * Make the builder finally-able for Promise.finally()
      */
-    finally(onfinally?: (() => void) | null): Promise<FetchResult<T>> {
+    finally(onfinally) {
         return this.send().finally(onfinally);
     }
 }
-
 /**
  * Create a fetch builder
  */
-export function juxFetch<T = any>(url: string, options: FetchOptions = {}): FetchBuilder<T> {
-    return new FetchBuilder<T>(url, options);
+export function juxFetch(url, options = {}) {
+    return new FetchBuilder(url, options);
 }
-
 /**
  * Convenience methods for common HTTP verbs
  */
 export const fetchHelpers = {
-    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' })
+    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' })
 };
-
 /**
  * Fetch multiple URLs in parallel
  */
-export async function fetchAll<T = any>(
-    urls: string[],
-    options?: FetchOptions
-): Promise<FetchResult<T>[]> {
-    return Promise.all(urls.map(url => executeFetch<T>(url, options)));
+export async function fetchAll(urls, options) {
+    return Promise.all(urls.map(url => executeFetch(url, options)));
 }
-
 /**
  * Get a service URL from window.juxConfig
  */
-export function getServiceUrl(serviceName: string): string | null {
-    if (typeof window === 'undefined') return null;
-
-    const juxConfig = (window as any).juxConfig;
-    if (!juxConfig?.services) return null;
-
+export function getServiceUrl(serviceName) {
+    if (typeof window === 'undefined')
+        return null;
+    const juxConfig = window.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: string) {
+export function serviceClient(serviceName) {
     const baseUrl = getServiceUrl(serviceName);
-
     if (!baseUrl) {
         console.warn(`[JUX Fetch] Service '${serviceName}' not found in juxConfig.services`);
     }
-
     return {
-        fetch: (url: string, options?: any) => {
+        fetch: (url, options) => {
             return juxFetch(url, {
                 ...options,
                 baseUrl: baseUrl || undefined
@@ -483,11 +368,10 @@ export function serviceClient(serviceName: string) {
         baseUrl
     };
 }
-
 /**
  * Setup fetch from juxconfig
  * Call this in your bootstrap function
- * 
+ *
  * Usage:
  *   export default {
  *     bootstrap: [
@@ -502,46 +386,36 @@ export async function setupConfig() {
         console.warn('[JUX Fetch] setupConfig() called outside browser environment');
         return;
     }
-
-    const juxConfig = (window as any).juxConfig;
-
+    const juxConfig = window.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: FetchConfig = {
+    const 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,

package/dist/lib/utils/formatId.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Convert a component ID to a human-readable label
+ *
+ * Examples:
+ *   'btn-1' → 'Btn 1'
+ *   'btn1' → 'Btn1'
+ *   'btn-primary-1' → 'Btn Primary 1'
+ *   'user-email-input' → 'User Email Input'
+ *   'firstName' → 'First Name'
+ *   'first_name' → 'First Name'
+ *
+ * @param id - Component ID (kebab-case, snake_case, or camelCase)
+ * @returns Human-readable label with proper capitalization
+ */
+export declare function formatIdAsLabel(id: string): string;
+//# sourceMappingURL=formatId.d.ts.map

package/dist/lib/utils/formatId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatId.d.ts","sourceRoot":"","sources":["../../../lib/utils/formatId.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAalD"}

package/{lib/utils/formatId.ts → dist/lib/utils/formatId.js}

@@ -1,6 +1,6 @@
 /**
  * Convert a component ID to a human-readable label
- * 
+ *
  * Examples:
  *   'btn-1' → 'Btn 1'
  *   'btn1' → 'Btn1'
@@ -8,19 +8,18 @@
  *   'user-email-input' → 'User Email Input'
  *   'firstName' → 'First Name'
  *   'first_name' → 'First Name'
- * 
+ *
  * @param id - Component ID (kebab-case, snake_case, or camelCase)
  * @returns Human-readable label with proper capitalization
  */
-export function formatIdAsLabel(id: string): string {
-    if (!id) return '';
-
+export function formatIdAsLabel(id) {
+    if (!id)
+        return '';
     // Split by common delimiters: hyphens, underscores, or camelCase boundaries
     const words = id
-        .replace(/([a-z])([A-Z])/g, '$1 $2')  // camelCase → separate words
-        .split(/[-_\s]+/)                      // Split by hyphens, underscores, spaces
+        .replace(/([a-z])([A-Z])/g, '$1 $2') // camelCase → separate words
+        .split(/[-_\s]+/) // Split by hyphens, underscores, spaces
         .filter(word => word.length > 0);
-
     // Capitalize first letter of each word
     return words
         .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())

package/dist/lib/utils/idgen.d.ts

@@ -0,0 +1,2 @@
+export default function generateId(prefix?: string, length?: number): string;
+//# sourceMappingURL=idgen.d.ts.map

package/dist/lib/utils/idgen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"idgen.d.ts","sourceRoot":"","sources":["../../../lib/utils/idgen.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,UAAU,UAAU,CAAC,MAAM,GAAE,MAAc,EAAE,MAAM,GAAE,MAAU,GAAG,MAAM,CAGrF"}

package/{lib/utils/idgen.ts → dist/lib/utils/idgen.js}

@@ -1,6 +1,4 @@
-
-
-export default function generateId(prefix: string = 'jux', length: number = 9): string {
+export default function generateId(prefix = 'jux', length = 9) {
     const randomPart = Math.random().toString(36).substr(2, length); // Generate a random string
     return `${prefix}-${randomPart}`;
-}
+}