@omnitron-dev/prism 0.2.0 → 0.3.0

package/dist/hooks/use-throttle.d.ts

@@ -0,0 +1,67 @@
+export interface UseThrottleOptions {
+    /** Whether to invoke on the leading edge (default: true) */
+    leading?: boolean;
+    /** Whether to invoke on the trailing edge (default: true) */
+    trailing?: boolean;
+}
+/**
+ * useThrottle - Throttle a value.
+ *
+ * Returns a throttled version of the value that only updates
+ * at most once per specified interval.
+ *
+ * @example
+ * ```tsx
+ * function SearchComponent() {
+ *   const [search, setSearch] = useState('');
+ *   const throttledSearch = useThrottle(search, 300);
+ *
+ *   // API call only triggers when throttledSearch changes
+ *   useEffect(() => {
+ *     if (throttledSearch) {
+ *       searchApi(throttledSearch);
+ *     }
+ *   }, [throttledSearch]);
+ *
+ *   return <input value={search} onChange={(e) => setSearch(e.target.value)} />;
+ * }
+ * ```
+ *
+ * @param value - Value to throttle
+ * @param delay - Throttle delay in milliseconds
+ * @param options - Throttle options
+ * @returns Throttled value
+ */
+export declare function useThrottle<T>(value: T, delay: number, options?: UseThrottleOptions): T;
+/**
+ * useThrottleCallback - Create a throttled callback function.
+ *
+ * Returns a memoized throttled version of the callback that only
+ * invokes at most once per specified interval.
+ *
+ * @example
+ * ```tsx
+ * function ScrollTracker() {
+ *   const handleScroll = useThrottleCallback(
+ *     (e: Event) => {
+ *       console.log('Scroll position:', window.scrollY);
+ *     },
+ *     100
+ *   );
+ *
+ *   useEffect(() => {
+ *     window.addEventListener('scroll', handleScroll);
+ *     return () => window.removeEventListener('scroll', handleScroll);
+ *   }, [handleScroll]);
+ *
+ *   return <div>Scroll me!</div>;
+ * }
+ * ```
+ *
+ * @param callback - Callback to throttle
+ * @param delay - Throttle delay in milliseconds
+ * @param options - Throttle options
+ * @returns Throttled callback
+ */
+export declare function useThrottleCallback<T extends (...args: unknown[]) => unknown>(callback: T, delay: number, options?: UseThrottleOptions): T;
+//# sourceMappingURL=use-throttle.d.ts.map

package/dist/hooks/use-throttle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-throttle.d.ts","sourceRoot":"","sources":["../../src/hooks/use-throttle.ts"],"names":[],"mappings":"AAgBA,MAAM,WAAW,kBAAkB;IACjC,4DAA4D;IAC5D,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,6DAA6D;IAC7D,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,kBAAuB,GAAG,CAAC,CA2C3F;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,EAC3E,QAAQ,EAAE,CAAC,EACX,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,kBAAuB,GAC/B,CAAC,CAqDH"}

package/dist/hooks/use-update-effect.d.ts

@@ -0,0 +1,53 @@
+/**
+ * useUpdateEffect Hook
+ *
+ * Like useEffect, but skips the first render.
+ * Useful for running effects only on updates, not on mount.
+ *
+ * @module @omnitron-dev/prism/hooks
+ */
+import { type DependencyList, type EffectCallback } from 'react';
+/**
+ * Effect hook that only runs on updates, not on initial mount.
+ *
+ * @param effect - Effect callback function
+ * @param deps - Dependency array
+ *
+ * @example
+ * ```tsx
+ * function SearchInput({ value, onSearch }) {
+ *   // Only search when value changes after initial render
+ *   useUpdateEffect(() => {
+ *     onSearch(value);
+ *   }, [value]);
+ *
+ *   return <input value={value} />;
+ * }
+ * ```
+ */
+export declare function useUpdateEffect(effect: EffectCallback, deps?: DependencyList): void;
+/**
+ * Layout effect hook that only runs on updates, not on initial mount.
+ * Uses useLayoutEffect for synchronous DOM measurements.
+ *
+ * @param effect - Effect callback function
+ * @param deps - Dependency array
+ *
+ * @example
+ * ```tsx
+ * function AnimatedComponent({ size }) {
+ *   const ref = useRef<HTMLDivElement>(null);
+ *
+ *   // Animate size changes, but not initial render
+ *   useUpdateLayoutEffect(() => {
+ *     if (ref.current) {
+ *       animate(ref.current, { width: size });
+ *     }
+ *   }, [size]);
+ *
+ *   return <div ref={ref} />;
+ * }
+ * ```
+ */
+export declare function useUpdateLayoutEffect(effect: EffectCallback, deps?: DependencyList): void;
+//# sourceMappingURL=use-update-effect.d.ts.map

package/dist/hooks/use-update-effect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-update-effect.d.ts","sourceRoot":"","sources":["../../src/hooks/use-update-effect.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AAEH,OAAO,EAAqB,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,OAAO,CAAC;AAMpF;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,cAAc,EAAE,IAAI,CAAC,EAAE,cAAc,GAAG,IAAI,CAYnF;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,cAAc,EAAE,IAAI,CAAC,EAAE,cAAc,GAAG,IAAI,CAazF"}

package/dist/hooks/use-window-size.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Window size data.
+ */
+export interface WindowSize {
+    /** Window width */
+    width: number;
+    /** Window height */
+    height: number;
+    /** Is mobile (< 600px) */
+    isMobile: boolean;
+    /** Is tablet (600px - 960px) */
+    isTablet: boolean;
+    /** Is desktop (>= 960px) */
+    isDesktop: boolean;
+    /** Is large desktop (>= 1280px) */
+    isLargeDesktop: boolean;
+}
+/**
+ * Breakpoint definitions (following MUI defaults).
+ */
+export interface Breakpoints {
+    xs: number;
+    sm: number;
+    md: number;
+    lg: number;
+    xl: number;
+}
+/**
+ * Options for useWindowSize hook.
+ */
+export interface UseWindowSizeOptions {
+    /** Custom breakpoints */
+    breakpoints?: Partial<Breakpoints>;
+    /** Debounce delay in ms (default: 100) */
+    debounce?: number;
+    /** Initial width for SSR (default: 1200) */
+    initialWidth?: number;
+    /** Initial height for SSR (default: 800) */
+    initialHeight?: number;
+}
+/**
+ * useWindowSize - Hook for tracking window dimensions.
+ *
+ * @example
+ * ```tsx
+ * // Basic usage
+ * const { width, height, isMobile, isDesktop } = useWindowSize();
+ *
+ * // Responsive rendering
+ * if (isMobile) {
+ *   return <MobileLayout />;
+ * }
+ * return <DesktopLayout />;
+ *
+ * // Responsive columns
+ * const columns = isMobile ? 1 : isTablet ? 2 : 4;
+ *
+ * // Custom breakpoints
+ * const { isMobile } = useWindowSize({
+ *   breakpoints: { sm: 768 }
+ * });
+ * ```
+ */
+export declare function useWindowSize(options?: UseWindowSizeOptions): WindowSize;
+/**
+ * Return type for useResponsiveQuery hook.
+ */
+export type UseResponsiveQueryReturn = boolean;
+/**
+ * useResponsiveQuery - Hook for CSS media query matching.
+ *
+ * Note: For the simpler MUI-style useMediaQuery, see @omnitron-dev/prism/core.
+ * This hook provides a standalone implementation without MUI dependency.
+ *
+ * @example
+ * ```tsx
+ * // Direct media query
+ * const prefersDark = useResponsiveQuery('(prefers-color-scheme: dark)');
+ * const isRetina = useResponsiveQuery('(min-resolution: 2dppx)');
+ *
+ * // Responsive
+ * const isLargeScreen = useResponsiveQuery('(min-width: 1200px)');
+ * ```
+ */
+export declare function useResponsiveQuery(query: string): UseResponsiveQueryReturn;
+/**
+ * useBreakpoint - Hook for checking current breakpoint.
+ *
+ * @example
+ * ```tsx
+ * const breakpoint = useBreakpoint();
+ *
+ * // Current breakpoint name
+ * console.log(breakpoint); // 'md'
+ *
+ * // Check specific breakpoint
+ * const { isUp, isDown, isOnly, isBetween } = useBreakpointChecks();
+ *
+ * if (isUp('md')) {
+ *   // Screen is md or larger
+ * }
+ * ```
+ */
+export declare function useBreakpoint(customBreakpoints?: Partial<Breakpoints>): 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+/**
+ * Return type for useBreakpointChecks hook.
+ */
+export interface BreakpointChecks {
+    /** Check if width is >= breakpoint */
+    isUp: (breakpoint: keyof Breakpoints) => boolean;
+    /** Check if width is < breakpoint */
+    isDown: (breakpoint: keyof Breakpoints) => boolean;
+    /** Check if width is within breakpoint range */
+    isOnly: (breakpoint: keyof Breakpoints) => boolean;
+    /** Check if width is between two breakpoints */
+    isBetween: (start: keyof Breakpoints, end: keyof Breakpoints) => boolean;
+}
+/**
+ * useBreakpointChecks - Hook for advanced breakpoint checking.
+ *
+ * @example
+ * ```tsx
+ * const { isUp, isDown, isOnly, isBetween } = useBreakpointChecks();
+ *
+ * isUp('md');           // true if >= 900px
+ * isDown('lg');         // true if < 1200px
+ * isOnly('md');         // true if 900px - 1199px
+ * isBetween('sm', 'lg'); // true if 600px - 1199px
+ * ```
+ */
+export declare function useBreakpointChecks(customBreakpoints?: Partial<Breakpoints>): BreakpointChecks;
+//# sourceMappingURL=use-window-size.d.ts.map

package/dist/hooks/use-window-size.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-window-size.d.ts","sourceRoot":"","sources":["../../src/hooks/use-window-size.ts"],"names":[],"mappings":"AAYA;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,mBAAmB;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,oBAAoB;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,0BAA0B;IAC1B,QAAQ,EAAE,OAAO,CAAC;IAClB,gCAAgC;IAChC,QAAQ,EAAE,OAAO,CAAC;IAClB,4BAA4B;IAC5B,SAAS,EAAE,OAAO,CAAC;IACnB,mCAAmC;IACnC,cAAc,EAAE,OAAO,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ;AAaD;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,yBAAyB;IACzB,WAAW,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;IACnC,0CAA0C;IAC1C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,4CAA4C;IAC5C,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,4CAA4C;IAC5C,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,aAAa,CAAC,OAAO,GAAE,oBAAyB,GAAG,UAAU,CAgE5E;AAED;;GAEG;AACH,MAAM,MAAM,wBAAwB,GAAG,OAAO,CAAC;AAE/C;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,wBAAwB,CA8B1E;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,aAAa,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CASxG;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,sCAAsC;IACtC,IAAI,EAAE,CAAC,UAAU,EAAE,MAAM,WAAW,KAAK,OAAO,CAAC;IACjD,qCAAqC;IACrC,MAAM,EAAE,CAAC,UAAU,EAAE,MAAM,WAAW,KAAK,OAAO,CAAC;IACnD,gDAAgD;IAChD,MAAM,EAAE,CAAC,UAAU,EAAE,MAAM,WAAW,KAAK,OAAO,CAAC;IACnD,gDAAgD;IAChD,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,WAAW,EAAE,GAAG,EAAE,MAAM,WAAW,KAAK,OAAO,CAAC;CAC1E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,GAAG,gBAAgB,CAuC9F"}

package/dist/http/client.d.ts

@@ -0,0 +1,74 @@
+/**
+ * HTTP Client Implementation
+ *
+ * Framework-agnostic HTTP client built on the Fetch API.
+ *
+ * @module http/client
+ */
+import type { HttpClient, HttpClientConfig } from './types.js';
+/**
+ * Create a new HTTP client instance.
+ *
+ * @param config - Client configuration
+ * @returns HTTP client instance
+ *
+ * @example
+ * ```ts
+ * // Create a basic client
+ * const api = createHttpClient({
+ *   baseUrl: 'https://api.example.com',
+ *   headers: {
+ *     'Authorization': 'Bearer token',
+ *   },
+ * });
+ *
+ * // Make requests
+ * const users = await api.get('/users');
+ * const newUser = await api.post('/users', { name: 'John' });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // With interceptors
+ * const api = createHttpClient({
+ *   baseUrl: 'https://api.example.com',
+ *   requestInterceptors: [
+ *     (config) => {
+ *       const token = getAuthToken();
+ *       if (token) {
+ *         config.headers = { ...config.headers, Authorization: `Bearer ${token}` };
+ *       }
+ *       return config;
+ *     },
+ *   ],
+ *   errorInterceptors: [
+ *     (error) => {
+ *       if (error.status === 401) {
+ *         // Handle unauthorized
+ *         refreshToken();
+ *       }
+ *       throw error;
+ *     },
+ *   ],
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // With retry
+ * const api = createHttpClient({
+ *   baseUrl: 'https://api.example.com',
+ *   retry: {
+ *     maxRetries: 3,
+ *     retryDelay: (attempt) => Math.min(1000 * 2 ** attempt, 10000),
+ *     retryCondition: (error) => error.status === 429 || error.status >= 500,
+ *   },
+ * });
+ * ```
+ */
+export declare function createHttpClient(config?: HttpClientConfig): HttpClient;
+/**
+ * Default HTTP client instance.
+ */
+export declare const http: HttpClient;
+//# sourceMappingURL=client.d.ts.map

package/dist/http/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/http/client.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EACV,UAAU,EACV,gBAAgB,EAQjB,MAAM,YAAY,CAAC;AA8XpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,GAAE,gBAAqB,GAAG,UAAU,CAE1E;AAED;;GAEG;AACH,eAAO,MAAM,IAAI,YAAqB,CAAC"}

package/dist/http/index.d.ts

@@ -1,233 +1,10 @@
 /**
- * HTTP Client Types
+ * HTTP Client Module
  *
- * Type definitions for the HTTP client module.
+ * Framework-agnostic HTTP client with interceptors, retry logic, and TypeScript support.
  *
- * @module @omnitron-dev/prism/http/types
+ * @module @omnitron-dev/prism/http
  */
-/**
- * HTTP request methods.
- */
-type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
-/**
- * Request headers type.
- */
-type HttpHeaders = Record<string, string>;
-/**
- * Request parameters type.
- */
-type HttpParams = Record<string, string | number | boolean | string[] | number[] | undefined>;
-/**
- * Request configuration.
- */
-interface HttpRequestConfig<TData = unknown> {
-    /** Request URL (relative or absolute) */
-    url: string;
-    /** HTTP method */
-    method?: HttpMethod;
-    /** Request headers */
-    headers?: HttpHeaders;
-    /** Query parameters */
-    params?: HttpParams;
-    /** Request body */
-    data?: TData;
-    /** Request timeout in ms */
-    timeout?: number;
-    /** Response type */
-    responseType?: 'json' | 'text' | 'blob' | 'arraybuffer';
-    /** Whether to include credentials */
-    withCredentials?: boolean;
-    /** AbortController signal */
-    signal?: AbortSignal;
-    /** Custom tags for middleware */
-    tags?: string[];
-    /** Skip response transformation */
-    rawResponse?: boolean;
-}
-/**
- * Response type from HTTP client.
- */
-interface HttpResponse<TData = unknown> {
-    /** Response data */
-    data: TData;
-    /** HTTP status code */
-    status: number;
-    /** Status text */
-    statusText: string;
-    /** Response headers */
-    headers: Record<string, string>;
-    /** Original request config */
-    config: HttpRequestConfig;
-}
-/**
- * HTTP error type.
- */
-interface HttpError<TData = unknown> extends Error {
-    /** Error name (always 'HttpError') */
-    name: 'HttpError';
-    /** HTTP status code (if response received) */
-    status?: number;
-    /** Status text */
-    statusText?: string;
-    /** Response data (if any) */
-    data?: TData;
-    /** Response headers */
-    headers?: Record<string, string>;
-    /** Original request config */
-    config: HttpRequestConfig;
-    /** Whether request was cancelled */
-    cancelled?: boolean;
-    /** Whether request timed out */
-    timeout?: boolean;
-}
-/**
- * Request interceptor function.
- */
-type RequestInterceptor = (config: HttpRequestConfig) => HttpRequestConfig | Promise<HttpRequestConfig>;
-/**
- * Response interceptor function.
- */
-type ResponseInterceptor<TData = unknown> = (response: HttpResponse<TData>) => HttpResponse<TData> | Promise<HttpResponse<TData>>;
-/**
- * Error interceptor function.
- */
-type ErrorInterceptor = (error: HttpError) => HttpError | Promise<HttpError> | never;
-/**
- * Retry condition function.
- */
-type RetryCondition = (error: HttpError, attempt: number) => boolean;
-/**
- * HTTP client configuration.
- */
-interface HttpClientConfig {
-    /** Base URL for all requests */
-    baseUrl?: string;
-    /** Default headers for all requests */
-    headers?: HttpHeaders;
-    /** Default timeout in ms */
-    timeout?: number;
-    /** Whether to include credentials by default */
-    withCredentials?: boolean;
-    /** Retry configuration */
-    retry?: {
-        /** Maximum number of retries */
-        maxRetries?: number;
-        /** Delay between retries in ms */
-        retryDelay?: number | ((attempt: number) => number);
-        /** Condition to determine if should retry */
-        retryCondition?: RetryCondition;
-    };
-    /** Request interceptors */
-    requestInterceptors?: RequestInterceptor[];
-    /** Response interceptors */
-    responseInterceptors?: ResponseInterceptor[];
-    /** Error interceptors */
-    errorInterceptors?: ErrorInterceptor[];
-}
-/**
- * HTTP client interface.
- */
-interface HttpClient {
-    /** Make a GET request */
-    get<TData = unknown>(url: string, config?: Omit<HttpRequestConfig, 'url' | 'method'>): Promise<HttpResponse<TData>>;
-    /** Make a POST request */
-    post<TData = unknown, TBody = unknown>(url: string, data?: TBody, config?: Omit<HttpRequestConfig, 'url' | 'method' | 'data'>): Promise<HttpResponse<TData>>;
-    /** Make a PUT request */
-    put<TData = unknown, TBody = unknown>(url: string, data?: TBody, config?: Omit<HttpRequestConfig, 'url' | 'method' | 'data'>): Promise<HttpResponse<TData>>;
-    /** Make a PATCH request */
-    patch<TData = unknown, TBody = unknown>(url: string, data?: TBody, config?: Omit<HttpRequestConfig, 'url' | 'method' | 'data'>): Promise<HttpResponse<TData>>;
-    /** Make a DELETE request */
-    delete<TData = unknown>(url: string, config?: Omit<HttpRequestConfig, 'url' | 'method'>): Promise<HttpResponse<TData>>;
-    /** Make a HEAD request */
-    head(url: string, config?: Omit<HttpRequestConfig, 'url' | 'method'>): Promise<HttpResponse<void>>;
-    /** Make an OPTIONS request */
-    options<TData = unknown>(url: string, config?: Omit<HttpRequestConfig, 'url' | 'method'>): Promise<HttpResponse<TData>>;
-    /** Make a request with full configuration */
-    request<TData = unknown>(config: HttpRequestConfig): Promise<HttpResponse<TData>>;
-    /** Add request interceptor */
-    addRequestInterceptor(interceptor: RequestInterceptor): () => void;
-    /** Add response interceptor */
-    addResponseInterceptor(interceptor: ResponseInterceptor): () => void;
-    /** Add error interceptor */
-    addErrorInterceptor(interceptor: ErrorInterceptor): () => void;
-    /** Get current configuration */
-    getConfig(): HttpClientConfig;
-    /** Create a new instance with merged config */
-    extend(config: HttpClientConfig): HttpClient;
-}
-
-/**
- * HTTP Client Implementation
- *
- * Framework-agnostic HTTP client built on the Fetch API.
- *
- * @module @omnitron-dev/prism/http/client
- */
-
-/**
- * Create a new HTTP client instance.
- *
- * @param config - Client configuration
- * @returns HTTP client instance
- *
- * @example
- * ```ts
- * // Create a basic client
- * const api = createHttpClient({
- *   baseUrl: 'https://api.example.com',
- *   headers: {
- *     'Authorization': 'Bearer token',
- *   },
- * });
- *
- * // Make requests
- * const users = await api.get('/users');
- * const newUser = await api.post('/users', { name: 'John' });
- * ```
- *
- * @example
- * ```ts
- * // With interceptors
- * const api = createHttpClient({
- *   baseUrl: 'https://api.example.com',
- *   requestInterceptors: [
- *     (config) => {
- *       const token = getAuthToken();
- *       if (token) {
- *         config.headers = { ...config.headers, Authorization: `Bearer ${token}` };
- *       }
- *       return config;
- *     },
- *   ],
- *   errorInterceptors: [
- *     (error) => {
- *       if (error.status === 401) {
- *         // Handle unauthorized
- *         refreshToken();
- *       }
- *       throw error;
- *     },
- *   ],
- * });
- * ```
- *
- * @example
- * ```ts
- * // With retry
- * const api = createHttpClient({
- *   baseUrl: 'https://api.example.com',
- *   retry: {
- *     maxRetries: 3,
- *     retryDelay: (attempt) => Math.min(1000 * 2 ** attempt, 10000),
- *     retryCondition: (error) => error.status === 429 || error.status >= 500,
- *   },
- * });
- * ```
- */
-declare function createHttpClient(config?: HttpClientConfig): HttpClient;
-/**
- * Default HTTP client instance.
- */
-declare const http: HttpClient;
-
-export { type ErrorInterceptor, type HttpClient, type HttpClientConfig, type HttpError, type HttpHeaders, type HttpMethod, type HttpParams, type HttpRequestConfig, type HttpResponse, type RequestInterceptor, type ResponseInterceptor, type RetryCondition, createHttpClient, http };
+export { createHttpClient, http } from './client.js';
+export type { HttpMethod, HttpHeaders, HttpParams, HttpRequestConfig, HttpResponse, HttpError, RequestInterceptor, ResponseInterceptor, ErrorInterceptor, RetryCondition, HttpClientConfig, HttpClient, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/http/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/http/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,gBAAgB,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAErD,YAAY,EACV,UAAU,EACV,WAAW,EACX,UAAU,EACV,iBAAiB,EACjB,YAAY,EACZ,SAAS,EACT,kBAAkB,EAClB,mBAAmB,EACnB,gBAAgB,EAChB,cAAc,EACd,gBAAgB,EAChB,UAAU,GACX,MAAM,YAAY,CAAC"}

package/dist/http/index.js

@@ -1,5 +1,3 @@
-import '../chunk-77KIJLPP.js';
-
 // src/http/client.ts
 var defaultRetryDelay = (attempt) => Math.min(1e3 * 2 ** attempt, 3e4);
 var defaultRetryCondition = (error, attempt) => {