juxscript 1.1.4 → 1.1.6

package/lib/reactivity/state.ts

@@ -0,0 +1,78 @@
+/**
+ * Simple reactive state container
+ */
+export class State<T> {
+    private _value: T;
+    private _subscribers: Set<(value: T) => void> = new Set();
+
+    constructor(initialValue: T) {
+        this._value = initialValue;
+    }
+
+    /**
+     * Get current value
+     */
+    get value(): T {
+        return this._value;
+    }
+
+    /**
+     * Set new value and notify subscribers
+     */
+    set(newValue: T): void {
+        this._value = newValue;
+        this._notify();
+    }
+
+    /**
+     * Subscribe to value changes
+     */
+    subscribe(callback: (value: T) => void): () => void {
+        this._subscribers.add(callback);
+        // Call immediately with current value
+        callback(this._value);
+        // Return unsubscribe function
+        return () => this._subscribers.delete(callback);
+    }
+
+    /**
+     * Notify all subscribers
+     */
+    private _notify(): void {
+        this._subscribers.forEach(callback => callback(this._value));
+    }
+
+    /**
+     * Helper methods for numeric state
+     */
+    increment(): void {
+        if (typeof this._value === 'number') {
+            this.set((this._value + 1) as T);
+        }
+    }
+
+    decrement(): void {
+        if (typeof this._value === 'number') {
+            this.set((this._value - 1) as T);
+        }
+    }
+
+    add(amount: number): void {
+        if (typeof this._value === 'number') {
+            this.set((this._value + amount) as T);
+        }
+    }
+
+    subtract(amount: number): void {
+        if (typeof this._value === 'number') {
+            this.set((this._value - amount) as T);
+        }
+    }
+}
+
+/**
+ * Factory function to create reactive state
+ */
+export function state<T>(initialValue: T): State<T> {
+    return new State(initialValue);
+}

package/lib/utils/fetch.d.ts

@@ -0,0 +1,176 @@
+/**
+ * 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({
+ *     baseUrl: 'https://api.example.com',
+ *     credentials: 'include',
+ *     timeout: 10000,
+ *     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')
+ *     .body({ name: 'John' })
+ *     .params({ limit: 10 })
+ *     .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;
+}
+/**
+ * Configure global fetch defaults
+ */
+export declare function configureFetch(config: FetchConfig): void;
+/**
+ * FetchBuilder class for method chaining
+ */
+declare class FetchBuilder<T = any> {
+    url: string;
+    options: FetchOptions;
+    constructor(url: string, options?: FetchOptions);
+    method(value: string): this;
+    body(value: any): this;
+    params(value: Record<string, any>): this;
+    headers(value: Record<string, string>): this;
+    header(key: string, value: string): this;
+    timeout(value: number): this;
+    credentials(value: RequestCredentials): this;
+    log(value: LogLevel): this;
+    parseResponse(value: boolean): this;
+    onUnauthorized(callback: () => void): this;
+    onError(callback: (error: FetchError) => void): this;
+    /**
+     * Execute the fetch request
+     */
+    send(): Promise<FetchResult<T>>;
+    /**
+     * Alias for send()
+     */
+    fetch(): Promise<FetchResult<T>>;
+    /**
+     * 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>;
+    /**
+     * Make the builder catchable for Promise.catch()
+     */
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<FetchResult<T> | TResult>;
+    /**
+     * Make the builder finally-able for Promise.finally()
+     */
+    finally(onfinally?: (() => void) | null): Promise<FetchResult<T>>;
+}
+/**
+ * Create a fetch builder
+ */
+export declare function juxFetch<T = any>(url: string, options?: FetchOptions): FetchBuilder<T>;
+/**
+ * Convenience methods for common HTTP verbs
+ */
+export declare const fetchHelpers: {
+    get: <T = any>(url: string, options?: Omit<FetchOptions, "method">) => FetchBuilder<T>;
+    post: <T = any>(url: string, body?: any, options?: Omit<FetchOptions, "method" | "body">) => FetchBuilder<T>;
+    put: <T = any>(url: string, body?: any, options?: Omit<FetchOptions, "method" | "body">) => FetchBuilder<T>;
+    patch: <T = any>(url: string, body?: any, options?: Omit<FetchOptions, "method" | "body">) => FetchBuilder<T>;
+    delete: <T = any>(url: string, options?: Omit<FetchOptions, "method">) => FetchBuilder<T>;
+};
+/**
+ * Fetch multiple URLs in parallel
+ */
+export declare function fetchAll<T = any>(urls: string[], options?: FetchOptions): Promise<FetchResult<T>[]>;
+/**
+ * Get a service URL from window.juxConfig
+ */
+export declare function getServiceUrl(serviceName: string): string | 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 declare function serviceClient(serviceName: string): {
+    fetch: (url: string, options?: any) => FetchBuilder<any>;
+    baseUrl: string | null;
+};
+/**
+ * Setup fetch from juxconfig
+ * Call this in your bootstrap function
+ *
+ * Usage:
+ *   export default {
+ *     bootstrap: [
+ *       async function initFetch() {
+ *         await jux.fetch.setupConfig();
+ *       }
+ *     ]
+ *   };
+ */
+export declare function setupConfig(): Promise<{
+    services: any;
+    getServiceUrl: typeof getServiceUrl;
+} | undefined>;
+export declare const fetchAPI: typeof juxFetch & {
+    all: typeof fetchAll;
+    get: <T = any>(url: string, options?: Omit<FetchOptions, "method">) => FetchBuilder<T>;
+    post: <T = any>(url: string, body?: any, options?: Omit<FetchOptions, "method" | "body">) => FetchBuilder<T>;
+    put: <T = any>(url: string, body?: any, options?: Omit<FetchOptions, "method" | "body">) => FetchBuilder<T>;
+    patch: <T = any>(url: string, body?: any, options?: Omit<FetchOptions, "method" | "body">) => FetchBuilder<T>;
+    delete: <T = any>(url: string, options?: Omit<FetchOptions, "method">) => FetchBuilder<T>;
+    config: typeof configureFetch;
+    setupConfig: typeof setupConfig;
+    getServiceUrl: typeof getServiceUrl;
+    serviceClient: typeof serviceClient;
+};
+export {};
+//# sourceMappingURL=fetch.d.ts.map

package/lib/utils/fetch.d.ts.map

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

package/lib/utils/fetch.js

@@ -0,0 +1,427 @@
+/**
+ * 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({
+ *     baseUrl: 'https://api.example.com',
+ *     credentials: 'include',
+ *     timeout: 10000,
+ *     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')
+ *     .body({ name: 'John' })
+ *     .params({ limit: 10 })
+ *     .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();
+ */
+// Global configuration
+let globalConfig = {
+    credentials: 'same-origin',
+    headers: {
+        'Content-Type': 'application/json'
+    },
+    timeout: 30000,
+    log: false
+};
+/**
+ * Configure global fetch defaults
+ */
+export function configureFetch(config) {
+    globalConfig = {
+        ...globalConfig,
+        ...config,
+        headers: {
+            ...globalConfig.headers,
+            ...config.headers
+        }
+    };
+}
+/**
+ * Build URL with query parameters
+ */
+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;
+    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;
+    // 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 = {
+        ...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') {
+            requestInit.body = JSON.stringify(body);
+        }
+        else {
+            requestInit.body = body;
+        }
+    }
+    // Log request
+    if (log === true) {
+        console.log(`[JUX Fetch] ${requestInit.method || 'GET'} ${fullUrl}`, {
+            headers: requestInit.headers,
+            body: requestInit.body,
+            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);
+        // Handle unauthorized
+        if (response.status === 401 || response.status === 403) {
+            if (onUnauthorized) {
+                onUnauthorized();
+            }
+        }
+        // Parse response
+        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 {
+                        errorData = json;
+                    }
+                }
+                catch (e) {
+                    // JSON parse error
+                }
+            }
+            else if (response.ok) {
+                // Non-JSON response, try to get text
+                try {
+                    data = (await response.text());
+                }
+                catch (e) {
+                    // Ignore text parse errors
+                }
+            }
+        }
+        // Check if request was successful
+        if (!response.ok) {
+            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,
+                status: response.status,
+                response
+            };
+        }
+        // Log success
+        if (log === true) {
+            console.log(`[JUX Fetch Success] ${requestInit.method || 'GET'} ${fullUrl}`, {
+                status: response.status,
+                data
+            });
+        }
+        return {
+            data,
+            error: null,
+            status: response.status,
+            response
+        };
+    }
+    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
+        };
+    }
+}
+/**
+ * FetchBuilder class for method chaining
+ */
+class FetchBuilder {
+    constructor(url, options = {}) {
+        this.options = {};
+        this.url = url;
+        this.options = options;
+    }
+    method(value) {
+        this.options.method = value;
+        return this;
+    }
+    body(value) {
+        this.options.body = value;
+        return this;
+    }
+    params(value) {
+        this.options.params = value;
+        return this;
+    }
+    headers(value) {
+        this.options.headers = { ...this.options.headers, ...value };
+        return this;
+    }
+    header(key, value) {
+        this.options.headers = { ...this.options.headers, [key]: value };
+        return this;
+    }
+    timeout(value) {
+        this.options.timeout = value;
+        return this;
+    }
+    credentials(value) {
+        this.options.credentials = value;
+        return this;
+    }
+    log(value) {
+        this.options.log = value;
+        return this;
+    }
+    parseResponse(value) {
+        this.options.parseResponse = value;
+        return this;
+    }
+    onUnauthorized(callback) {
+        this.options.onUnauthorized = callback;
+        return this;
+    }
+    onError(callback) {
+        this.options.onError = callback;
+        return this;
+    }
+    /**
+     * Execute the fetch request
+     */
+    send() {
+        return executeFetch(this.url, this.options);
+    }
+    /**
+     * Alias for send()
+     */
+    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(onfulfilled, onrejected) {
+        return this.send().then(onfulfilled, onrejected);
+    }
+    /**
+     * Make the builder catchable for Promise.catch()
+     */
+    catch(onrejected) {
+        return this.send().catch(onrejected);
+    }
+    /**
+     * Make the builder finally-able for Promise.finally()
+     */
+    finally(onfinally) {
+        return this.send().finally(onfinally);
+    }
+}
+/**
+ * Create a fetch builder
+ */
+export function juxFetch(url, options = {}) {
+    return new FetchBuilder(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' })
+};
+/**
+ * Fetch multiple URLs in parallel
+ */
+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) {
+    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) {
+    const baseUrl = getServiceUrl(serviceName);
+    if (!baseUrl) {
+        console.warn(`[JUX Fetch] Service '${serviceName}' not found in juxConfig.services`);
+    }
+    return {
+        fetch: (url, options) => {
+            return juxFetch(url, {
+                ...options,
+                baseUrl: baseUrl || undefined
+            });
+        },
+        baseUrl
+    };
+}
+/**
+ * Setup fetch from juxconfig
+ * Call this in your bootstrap function
+ *
+ * Usage:
+ *   export default {
+ *     bootstrap: [
+ *       async function initFetch() {
+ *         await jux.fetch.setupConfig();
+ *       }
+ *     ]
+ *   };
+ */
+export async function setupConfig() {
+    if (typeof window === 'undefined') {
+        console.warn('[JUX Fetch] setupConfig() called outside browser environment');
+        return;
+    }
+    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 = {
+        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,
+    setupConfig,
+    getServiceUrl,
+    serviceClient,
+    ...fetchHelpers,
+    all: fetchAll
+});