@zap-js/client 0.0.2 → 0.0.4

package/dist/runtime/router.js

@@ -0,0 +1,435 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+/**
+ * ZapJS Production Router
+ *
+ * Features:
+ * - Nested layouts
+ * - Route-level middleware
+ * - Code splitting
+ * - Error boundaries
+ * - Type-safe navigation
+ */
+import React, { createContext, useContext, useState, useEffect, useCallback, useMemo, useTransition, Suspense, memo, } from 'react';
+import { composeMiddleware } from './middleware.js';
+const RouterContext = createContext(null);
+// ============================================================================
+// Route Matching
+// ============================================================================
+function matchRoute(pathname, routes) {
+    const normalizedPath = pathname === '' ? '/' : pathname;
+    for (const route of routes) {
+        const match = normalizedPath.match(route.pattern);
+        if (match) {
+            const params = {};
+            route.paramNames.forEach((name, index) => {
+                const value = match[index + 1];
+                if (value !== undefined && value !== '') {
+                    params[name] = decodeURIComponent(value);
+                }
+            });
+            return { route, params, pathname: normalizedPath };
+        }
+    }
+    return null;
+}
+function parseUrl(url) {
+    try {
+        const parsed = new URL(url, window.location.origin);
+        return {
+            pathname: parsed.pathname,
+            search: parsed.search,
+            hash: parsed.hash,
+        };
+    }
+    catch {
+        const hashIndex = url.indexOf('#');
+        const searchIndex = url.indexOf('?');
+        let pathname = url;
+        let search = '';
+        let hash = '';
+        if (hashIndex !== -1) {
+            hash = url.slice(hashIndex);
+            pathname = url.slice(0, hashIndex);
+        }
+        if (searchIndex !== -1 && (hashIndex === -1 || searchIndex < hashIndex)) {
+            search = pathname.slice(searchIndex, hashIndex !== -1 ? hashIndex - searchIndex : undefined);
+            pathname = pathname.slice(0, searchIndex);
+        }
+        return { pathname: pathname || '/', search, hash };
+    }
+}
+// ============================================================================
+// Middleware Runner
+// ============================================================================
+async function runRouteMiddleware(match, pathname, search, hash, state) {
+    if (!match.route.middleware) {
+        return { allowed: true };
+    }
+    try {
+        const middlewares = await match.route.middleware();
+        const composedMiddleware = composeMiddleware(middlewares);
+        const context = {
+            match,
+            pathname,
+            search,
+            hash,
+            state,
+        };
+        const result = await composedMiddleware(context);
+        switch (result.type) {
+            case 'continue':
+                return { allowed: true, data: result.data };
+            case 'redirect':
+                return { allowed: false, redirectTo: result.redirectTo };
+            case 'block':
+                return { allowed: false, error: result.error };
+            default:
+                return { allowed: true };
+        }
+    }
+    catch (error) {
+        console.error('Middleware execution failed:', error);
+        return { allowed: true }; // Allow navigation on middleware error
+    }
+}
+const LayoutWrapper = memo(({ layouts, layoutPath, children }) => {
+    if (!layoutPath) {
+        return _jsx(_Fragment, { children: children });
+    }
+    const layoutChain = [];
+    let currentPath = layoutPath;
+    while (currentPath) {
+        const layout = layouts.find(l => l.path === currentPath);
+        if (layout) {
+            layoutChain.unshift(layout);
+            currentPath = layout.parentLayout;
+        }
+        else {
+            break;
+        }
+    }
+    return layoutChain.reduce((content, layout) => {
+        const LayoutComponent = layout.component;
+        return (_jsx(Suspense, { fallback: _jsx("div", { children: "Loading layout..." }), children: _jsx(LayoutComponent, { children: content }) }));
+    }, children);
+});
+LayoutWrapper.displayName = 'LayoutWrapper';
+export function RouterProvider({ routes, layouts = [], children, notFound: NotFound, fallback = null, onRouteError, }) {
+    const [isPending, startTransition] = useTransition();
+    const [state, setState] = useState(() => {
+        const { pathname, search, hash } = parseUrl(window.location.href);
+        return {
+            pathname,
+            search,
+            hash,
+            match: matchRoute(pathname, routes),
+        };
+    });
+    const navigate = useCallback(async (path, options = {}) => {
+        const { replace = false, scroll = true } = options;
+        const { pathname, search, hash } = parseUrl(path);
+        // Find route match
+        const match = matchRoute(pathname, routes);
+        if (match) {
+            // Run middleware
+            const { allowed, redirectTo, error, data } = await runRouteMiddleware(match, pathname, search, hash, options.state);
+            if (!allowed) {
+                if (redirectTo) {
+                    // Redirect instead
+                    navigate(redirectTo, { replace: true });
+                    return;
+                }
+                if (error) {
+                    onRouteError?.(error);
+                    throw error;
+                }
+                return;
+            }
+            // Update URL
+            const url = pathname + search + hash;
+            if (replace) {
+                window.history.replaceState(options.state ?? null, '', url);
+            }
+            else {
+                window.history.pushState(options.state ?? null, '', url);
+            }
+            // Update state with middleware data
+            startTransition(() => {
+                setState({
+                    pathname,
+                    search,
+                    hash,
+                    match,
+                    middlewareData: data,
+                });
+            });
+            if (scroll) {
+                if (hash) {
+                    const element = document.querySelector(hash);
+                    element?.scrollIntoView();
+                }
+                else {
+                    window.scrollTo(0, 0);
+                }
+            }
+        }
+        else {
+            // No match - update anyway to show 404
+            const url = pathname + search + hash;
+            if (replace) {
+                window.history.replaceState(options.state ?? null, '', url);
+            }
+            else {
+                window.history.pushState(options.state ?? null, '', url);
+            }
+            startTransition(() => {
+                setState({
+                    pathname,
+                    search,
+                    hash,
+                    match: null,
+                });
+            });
+        }
+    }, [routes, onRouteError]);
+    const router = useMemo(() => ({
+        push: (path, options) => navigate(path, options),
+        replace: (path, options) => navigate(path, { ...options, replace: true }),
+        back: () => window.history.back(),
+        forward: () => window.history.forward(),
+        refresh: () => {
+            startTransition(() => {
+                setState((prev) => ({ ...prev, match: matchRoute(prev.pathname, routes) }));
+            });
+        },
+        prefetch: (path) => {
+            const { pathname } = parseUrl(path);
+            const match = matchRoute(pathname, routes);
+            if (match?.route.component) {
+                const component = match.route.component;
+                if (component._payload && component._init) {
+                    try {
+                        component._init(component._payload);
+                    }
+                    catch {
+                        // Component will load when rendered
+                    }
+                }
+            }
+        },
+    }), [navigate, routes]);
+    useEffect(() => {
+        const handlePopState = async () => {
+            const { pathname, search, hash } = parseUrl(window.location.href);
+            const match = matchRoute(pathname, routes);
+            if (match) {
+                // Run middleware for browser navigation too
+                const { allowed, redirectTo, error, data } = await runRouteMiddleware(match, pathname, search, hash);
+                if (!allowed) {
+                    if (redirectTo) {
+                        navigate(redirectTo, { replace: true });
+                        return;
+                    }
+                    if (error) {
+                        onRouteError?.(error);
+                        return;
+                    }
+                }
+                startTransition(() => {
+                    setState({
+                        pathname,
+                        search,
+                        hash,
+                        match,
+                        middlewareData: data,
+                    });
+                });
+            }
+            else {
+                startTransition(() => {
+                    setState({
+                        pathname,
+                        search,
+                        hash,
+                        match: null,
+                    });
+                });
+            }
+        };
+        window.addEventListener('popstate', handlePopState);
+        return () => window.removeEventListener('popstate', handlePopState);
+    }, [routes, navigate, onRouteError]);
+    // Update document meta on route change
+    useEffect(() => {
+        if (state.match?.route.meta) {
+            state.match.route.meta().then((meta) => {
+                if (meta.title) {
+                    document.title = meta.title;
+                }
+                if (meta.description) {
+                    const metaDesc = document.querySelector('meta[name="description"]');
+                    if (metaDesc) {
+                        metaDesc.setAttribute('content', meta.description);
+                    }
+                }
+            }).catch(() => {
+                // Ignore meta errors
+            });
+        }
+    }, [state.match]);
+    const contextValue = useMemo(() => ({
+        state,
+        router,
+        routes,
+        layouts,
+        isPending,
+    }), [state, router, routes, layouts, isPending]);
+    return (_jsx(RouterContext.Provider, { value: contextValue, children: _jsx(Suspense, { fallback: fallback, children: children }) }));
+}
+// ============================================================================
+// Hooks
+// ============================================================================
+export function useRouter() {
+    const context = useContext(RouterContext);
+    if (!context) {
+        throw new Error('useRouter must be used within a RouterProvider');
+    }
+    return context.router;
+}
+export function useParams() {
+    const context = useContext(RouterContext);
+    if (!context) {
+        throw new Error('useParams must be used within a RouterProvider');
+    }
+    return (context.state.match?.params ?? {});
+}
+export function usePathname() {
+    const context = useContext(RouterContext);
+    if (!context) {
+        throw new Error('usePathname must be used within a RouterProvider');
+    }
+    return context.state.pathname;
+}
+export function useSearchParams() {
+    const context = useContext(RouterContext);
+    if (!context) {
+        throw new Error('useSearchParams must be used within a RouterProvider');
+    }
+    const searchParams = useMemo(() => new URLSearchParams(context.state.search), [context.state.search]);
+    const setSearchParams = useCallback((params) => {
+        const newParams = new URLSearchParams(params);
+        const newSearch = newParams.toString();
+        const path = context.state.pathname + (newSearch ? `?${newSearch}` : '') + context.state.hash;
+        context.router.push(path, { scroll: false });
+    }, [context.router, context.state.pathname, context.state.hash]);
+    return [searchParams, setSearchParams];
+}
+export function useMiddlewareData() {
+    const context = useContext(RouterContext);
+    if (!context) {
+        throw new Error('useMiddlewareData must be used within a RouterProvider');
+    }
+    return context.state.middlewareData;
+}
+export function useRouteMatch() {
+    const context = useContext(RouterContext);
+    if (!context) {
+        throw new Error('useRouteMatch must be used within a RouterProvider');
+    }
+    return context.state.match;
+}
+export function useIsPending() {
+    const context = useContext(RouterContext);
+    if (!context) {
+        throw new Error('useIsPending must be used within a RouterProvider');
+    }
+    return context.isPending;
+}
+export function Link({ to, replace = false, prefetch = true, scroll = true, children, onClick, onMouseEnter, ...props }) {
+    const context = useContext(RouterContext);
+    const handleClick = useCallback((e) => {
+        onClick?.(e);
+        if (e.defaultPrevented ||
+            e.button !== 0 ||
+            e.metaKey ||
+            e.ctrlKey ||
+            e.shiftKey ||
+            e.altKey) {
+            return;
+        }
+        const href = to;
+        if (href.startsWith('http://') || href.startsWith('https://') || href.startsWith('//')) {
+            return;
+        }
+        e.preventDefault();
+        context?.router[replace ? 'replace' : 'push'](to, { scroll });
+    }, [context?.router, to, replace, scroll, onClick]);
+    const handleMouseEnter = useCallback((e) => {
+        onMouseEnter?.(e);
+        if (prefetch && context) {
+            context.router.prefetch(to);
+        }
+    }, [context, to, prefetch, onMouseEnter]);
+    return (_jsx("a", { href: to, onClick: handleClick, onMouseEnter: handleMouseEnter, ...props, children: children }));
+}
+export function Outlet({ notFound: NotFound, fallback = null }) {
+    const context = useContext(RouterContext);
+    if (!context) {
+        throw new Error('Outlet must be used within a RouterProvider');
+    }
+    const { match, middlewareData } = context.state;
+    if (!match) {
+        return NotFound ? _jsx(NotFound, {}) : null;
+    }
+    const { route, params } = match;
+    const Component = route.component;
+    const ErrorComponent = route.errorComponent;
+    const PendingComponent = route.pendingComponent;
+    const routeElement = (_jsx(Suspense, { fallback: PendingComponent ? _jsx(PendingComponent, {}) : fallback, children: _jsx(Component, { params: params, ...middlewareData }) }));
+    const wrappedElement = (_jsx(LayoutWrapper, { layouts: context.layouts, layoutPath: route.layoutPath, children: ErrorComponent ? (_jsx(RouteErrorBoundary, { fallback: _jsx(ErrorComponent, {}), children: routeElement })) : routeElement }));
+    return wrappedElement;
+}
+class RouteErrorBoundary extends React.Component {
+    constructor(props) {
+        super(props);
+        this.state = { hasError: false, error: null };
+    }
+    static getDerivedStateFromError(error) {
+        return { hasError: true, error };
+    }
+    componentDidCatch(error, errorInfo) {
+        console.error('Route error:', error, errorInfo);
+    }
+    render() {
+        if (this.state.hasError) {
+            return this.props.fallback;
+        }
+        return this.props.children;
+    }
+}
+export function NavLink({ to, activeClassName, activeStyle, exact = false, pending = false, pendingClassName, pendingStyle, className, style, ...props }) {
+    const pathname = usePathname();
+    const isPending = useIsPending();
+    const isActive = exact
+        ? pathname === to
+        : pathname.startsWith(to) && (to === '/' ? pathname === '/' : true);
+    const isPendingRoute = pending && isPending;
+    const combinedClassName = [
+        className,
+        isActive && activeClassName,
+        isPendingRoute && pendingClassName,
+    ].filter(Boolean).join(' ').trim() || undefined;
+    const combinedStyle = {
+        ...style,
+        ...(isActive ? activeStyle : {}),
+        ...(isPendingRoute ? pendingStyle : {}),
+    };
+    return (_jsx(Link, { to: to, className: combinedClassName, style: combinedStyle, ...props }));
+}
+export function Redirect({ to, replace = true }) {
+    const router = useRouter();
+    useEffect(() => {
+        router[replace ? 'replace' : 'push'](to);
+    }, [router, to, replace]);
+    return null;
+}

package/dist/runtime/rpc-client.d.ts

@@ -0,0 +1,35 @@
+/**
+ * RPC Client for calling Rust server functions from TypeScript
+ */
+import { IpcClient } from './ipc-client.js';
+/**
+ * Custom error class for RPC errors
+ */
+export declare class RpcError extends Error {
+    readonly errorType: string;
+    constructor(errorType: string, message: string);
+}
+/**
+ * Initialize the RPC client with a socket path
+ */
+export declare function initRpcClient(socketPath: string): void;
+/**
+ * Call a Rust server function via RPC
+ */
+export declare function rpcCall<T = unknown>(functionName: string, params?: Record<string, unknown>, timeoutMs?: number): Promise<T>;
+/**
+ * Wait for a response from a specific request
+ */
+export declare function waitForResponse<T = unknown>(requestId: string, timeoutMs?: number): Promise<T>;
+/**
+ * Close the RPC client connection
+ */
+export declare function closeRpcClient(): Promise<void>;
+/**
+ * Check if RPC client is initialized
+ */
+export declare function isRpcClientInitialized(): boolean;
+/**
+ * Get current RPC client instance (for advanced usage)
+ */
+export declare function getRpcClient(): IpcClient | null;

package/dist/runtime/rpc-client.js

@@ -0,0 +1,140 @@
+/**
+ * RPC Client for calling Rust server functions from TypeScript
+ */
+import { IpcClient } from './ipc-client.js';
+import { isRpcResponseMessage, isRpcErrorMessage } from './types.js';
+let ipcClient = null;
+let requestCounter = 0;
+const pendingRequests = new Map();
+/**
+ * Custom error class for RPC errors
+ */
+export class RpcError extends Error {
+    constructor(errorType, message) {
+        super(message);
+        this.errorType = errorType;
+        this.name = 'RpcError';
+        // Restore prototype chain for proper instanceof checks
+        Object.setPrototypeOf(this, RpcError.prototype);
+    }
+}
+/**
+ * Initialize the RPC client with a socket path
+ */
+export function initRpcClient(socketPath) {
+    if (ipcClient) {
+        throw new Error('RPC client already initialized');
+    }
+    ipcClient = new IpcClient(socketPath);
+    // Setup response handler
+    ipcClient.on('message', (message) => {
+        // Validate message structure
+        if (!message || typeof message !== 'object') {
+            return;
+        }
+        const msg = message;
+        if (isRpcResponseMessage(msg) && msg.request_id) {
+            const pending = pendingRequests.get(msg.request_id);
+            if (pending) {
+                clearTimeout(pending.timeout);
+                pending.resolve(msg.result);
+                pendingRequests.delete(msg.request_id);
+            }
+        }
+        else if (isRpcErrorMessage(msg) && msg.request_id) {
+            const pending = pendingRequests.get(msg.request_id);
+            if (pending) {
+                clearTimeout(pending.timeout);
+                const error = new RpcError(msg.error_type || 'UnknownError', msg.error || 'Unknown error');
+                pending.reject(error);
+                pendingRequests.delete(msg.request_id);
+            }
+        }
+    });
+    ipcClient.on('error', (error) => {
+        // Reject all pending requests on connection error
+        for (const [, pending] of pendingRequests) {
+            clearTimeout(pending.timeout);
+            pending.reject(error);
+        }
+        pendingRequests.clear();
+    });
+}
+/**
+ * Call a Rust server function via RPC
+ */
+export async function rpcCall(functionName, params = {}, timeoutMs = 30000) {
+    if (!ipcClient) {
+        throw new Error('RPC client not initialized. Call initRpcClient() first.');
+    }
+    const requestId = `req_${Date.now()}_${requestCounter++}`;
+    const message = {
+        type: 'rpc_call',
+        function_name: functionName,
+        params,
+        request_id: requestId,
+    };
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            pendingRequests.delete(requestId);
+            reject(new RpcError('TimeoutError', `RPC call to ${functionName} timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        pendingRequests.set(requestId, {
+            resolve: resolve,
+            reject,
+            timeout,
+        });
+        try {
+            ipcClient.send(message);
+        }
+        catch (error) {
+            clearTimeout(timeout);
+            pendingRequests.delete(requestId);
+            reject(error instanceof Error ? error : new Error(String(error)));
+        }
+    });
+}
+/**
+ * Wait for a response from a specific request
+ */
+export async function waitForResponse(requestId, timeoutMs = 30000) {
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            pendingRequests.delete(requestId);
+            reject(new RpcError('TimeoutError', `Request ${requestId} timed out`));
+        }, timeoutMs);
+        const handler = {
+            resolve: resolve,
+            reject,
+            timeout,
+        };
+        pendingRequests.set(requestId, handler);
+    });
+}
+/**
+ * Close the RPC client connection
+ */
+export async function closeRpcClient() {
+    if (ipcClient) {
+        // Reject all pending requests
+        for (const [, pending] of pendingRequests) {
+            clearTimeout(pending.timeout);
+            pending.reject(new Error('RPC client closed'));
+        }
+        pendingRequests.clear();
+        await ipcClient.close();
+        ipcClient = null;
+    }
+}
+/**
+ * Check if RPC client is initialized
+ */
+export function isRpcClientInitialized() {
+    return ipcClient !== null;
+}
+/**
+ * Get current RPC client instance (for advanced usage)
+ */
+export function getRpcClient() {
+    return ipcClient;
+}

package/dist/runtime/streaming-utils.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Streaming utilities for ZapJS
+ * Helper functions for working with streaming responses
+ */
+import type { StreamChunk } from './types.js';
+import { isAsyncIterable } from './types.js';
+export { isAsyncIterable };
+/**
+ * Create a StreamChunk from string data
+ * @param data - String data to send
+ * @returns StreamChunk with data field
+ */
+export declare function createChunk(data: string): StreamChunk;
+/**
+ * Create a StreamChunk from binary data
+ * @param bytes - Binary data to send
+ * @returns StreamChunk with bytes field
+ */
+export declare function createChunk(bytes: Uint8Array): StreamChunk;
+/**
+ * Create a streaming response from an array of strings
+ * @param items - Array of strings to stream
+ * @param delimiter - Optional delimiter to add after each item (default: newline)
+ * @returns Async iterable of stream chunks
+ */
+export declare function createStream(items: string[], delimiter?: string): AsyncIterable<StreamChunk>;
+/**
+ * Create a streaming JSON response (NDJSON format)
+ * Each object is sent as a separate JSON line
+ * @param objects - Array of objects to stream
+ * @returns Async iterable of stream chunks
+ */
+export declare function streamJson<T = any>(objects: T[]): AsyncIterable<StreamChunk>;
+/**
+ * Stream Server-Sent Events (SSE) format
+ * @param events - Array of SSE events
+ * @returns Async iterable of stream chunks
+ */
+export declare function streamSSE(events: Array<{
+    data: any;
+    event?: string;
+    id?: string | number;
+    retry?: number;
+}>): AsyncIterable<StreamChunk>;
+/**
+ * Transform an async iterable with a mapper function
+ * @param source - Source async iterable
+ * @param mapper - Function to transform each item
+ * @returns Async iterable of transformed items
+ */
+export declare function mapStream<T, U>(source: AsyncIterable<T>, mapper: (item: T) => U | Promise<U>): AsyncIterable<U>;
+/**
+ * Filter an async iterable with a predicate function
+ * @param source - Source async iterable
+ * @param predicate - Function to test each item
+ * @returns Async iterable of filtered items
+ */
+export declare function filterStream<T>(source: AsyncIterable<T>, predicate: (item: T) => boolean | Promise<boolean>): AsyncIterable<T>;
+/**
+ * Batch stream chunks together
+ * @param source - Source async iterable
+ * @param batchSize - Number of items per batch
+ * @returns Async iterable of batched items
+ */
+export declare function batchStream<T>(source: AsyncIterable<T>, batchSize: number): AsyncIterable<T[]>;
+/**
+ * Add delay between stream chunks
+ * @param source - Source async iterable
+ * @param delayMs - Delay in milliseconds between chunks
+ * @returns Async iterable with delays
+ */
+export declare function delayStream<T>(source: AsyncIterable<T>, delayMs: number): AsyncIterable<T>;
+/**
+ * Convert a ReadableStream to an async iterable
+ * @param stream - ReadableStream to convert
+ * @returns Async iterable
+ */
+export declare function fromReadableStream<T>(stream: ReadableStream<T>): AsyncIterable<T>;
+/**
+ * Create a streaming response that emits at regular intervals
+ * @param interval - Interval in milliseconds
+ * @param maxCount - Maximum number of emissions (optional)
+ * @param generator - Function to generate data for each emission
+ * @returns Async iterable of stream chunks
+ */
+export declare function intervalStream<T>(interval: number, generator: (count: number) => T, maxCount?: number): AsyncIterable<StreamChunk>;