@float.js/core 2.0.1

package/dist/index.d.ts

@@ -0,0 +1,400 @@
+import { FloatRoute as Route } from './router/index.js';
+export { FloatRouterOptions, matchRoute, scanRoutes } from './router/index.js';
+export { DevServer, DevServerOptions, PageProps, ProdServerOptions, RenderOptions, createDevServer, renderPage, renderPageStream, startProductionServer } from './server/index.js';
+import * as esbuild from 'esbuild';
+export { ComponentType, FC, ReactElement, ReactNode } from 'react';
+export { AIProvider, AIResponse, AnthropicProvider, ChatOptions, Message, OpenAIProvider, ai, aiAction, sseResponse, streamResponse } from './ai/index.js';
+export { FloatValidationError, Infer, error, f, json, redirect, typedRoute } from './api/index.js';
+export { FloatRealtime, PresenceState, RealtimeClient, RealtimeMessage, RealtimeOptions, RealtimeRoom, createRealtimeClient, getRealtimeServer, realtime } from './realtime/index.js';
+export { BuildInfo, DevDashboardOptions, PerformanceMetrics, RequestLog, RouteInfo, createDevDashboard, createRequestLogger, dashboardState, devtools } from './devtools/index.js';
+export { ImageConfig, ImageProps, OptimizedImage, StaticImageData, configureImages, createImageHandler, floatImageLoader, generateSrcSet, getImageConfig, getImageProps, image, renderImageToString } from './image/index.js';
+export { GeoData, MiddlewareConfig, MiddlewareHandler, MiddlewareRequest, NextResponse, NextURL, clearMiddleware, createMiddlewareHandler, middleware, middlewareHelpers, registerMiddleware } from './middleware/index.js';
+export { CachedPage, GenerateResult, GetStaticPathsResult, GetStaticPropsContext, GetStaticPropsResult, SSGConfig, SSGEngine, StaticPath, configureSSG, createRevalidateHandler, createSSGHandler, defineStaticPaths, defineStaticProps, getSSGEngine, default as ssg } from './ssg/index.js';
+export { AnalyticsConfig, AnalyticsData, AnalyticsEngine, AnalyticsSummary, CustomEvent, PageView, WebVitals, default as analytics, analyticsClientScript, configureAnalytics, createAnalyticsHandler, createAnalyticsMiddleware, getAnalytics } from './analytics/index.js';
+import 'ws';
+import 'http';
+import 'events';
+
+declare const VERSION = "2.0.1";
+
+/**
+ * Float.js Build System
+ * Fast builds with esbuild
+ */
+
+interface BuildOptions {
+    analyze?: boolean;
+    minify?: boolean;
+    sourcemap?: boolean;
+}
+interface BuildResult {
+    routes: Route[];
+    duration: number;
+    outputDir: string;
+    pages: string[];
+    assets: string[];
+}
+declare function build(options?: BuildOptions): Promise<BuildResult>;
+
+/**
+ * Float.js Transform
+ * On-the-fly TypeScript/JSX transformation
+ */
+
+/**
+ * Transform and import a file
+ * Handles .ts, .tsx, .js, .jsx files
+ */
+declare function transformFile(filePath: string): Promise<any>;
+/**
+ * Clear module cache (for HMR)
+ */
+declare function clearModuleCache(filePath?: string): void;
+/**
+ * Transform source code without file operations
+ */
+declare function transformSource(source: string, options?: {
+    filename?: string;
+    loader?: esbuild.Loader;
+}): Promise<string>;
+
+/**
+ * Float.js Router Hook
+ * Modern client-side routing utilities
+ */
+interface FloatRouterState {
+    pathname: string;
+    search: string;
+    hash: string;
+    params: Record<string, string>;
+    query: Record<string, string>;
+}
+interface FloatRouter extends FloatRouterState {
+    push: (url: string, options?: NavigateOptions) => void;
+    replace: (url: string, options?: NavigateOptions) => void;
+    back: () => void;
+    forward: () => void;
+    prefetch: (url: string) => void;
+    refresh: () => void;
+}
+interface NavigateOptions {
+    scroll?: boolean;
+    shallow?: boolean;
+}
+/**
+ * Access Float.js router for client-side navigation
+ * @example
+ * const router = useFloatRouter();
+ * router.push('/dashboard');
+ */
+declare function useFloatRouter(): FloatRouter;
+
+/**
+ * Float.js Data Hook
+ * SWR-like data fetching with caching
+ */
+interface FloatDataOptions<T> {
+    /** Initial data before fetching */
+    fallbackData?: T;
+    /** Revalidate on window focus */
+    revalidateOnFocus?: boolean;
+    /** Revalidate on network reconnect */
+    revalidateOnReconnect?: boolean;
+    /** Refresh interval in milliseconds */
+    refreshInterval?: number;
+    /** Dedupe requests within this time window (ms) */
+    dedupingInterval?: number;
+    /** Keep previous data when revalidating */
+    keepPreviousData?: boolean;
+    /** Custom fetcher function */
+    fetcher?: (url: string) => Promise<T>;
+}
+interface FloatDataResult<T> {
+    data: T | undefined;
+    error: Error | undefined;
+    isLoading: boolean;
+    isValidating: boolean;
+    mutate: (data?: T | Promise<T> | ((current?: T) => T | Promise<T>)) => Promise<T | undefined>;
+    refresh: () => Promise<void>;
+}
+/**
+ * Fetch and cache data with automatic revalidation
+ * @example
+ * const { data, error, isLoading } = useFloatData('/api/users');
+ */
+declare function useFloatData<T = any>(key: string | null, options?: FloatDataOptions<T>): FloatDataResult<T>;
+
+/**
+ * Float.js Form Hook
+ * Modern form handling with validation
+ */
+type ValidationRule<T> = (value: T, formData: Record<string, any>) => string | undefined | Promise<string | undefined>;
+interface FieldState<T = any> {
+    value: T;
+    error: string | undefined;
+    touched: boolean;
+    dirty: boolean;
+}
+interface FloatFormOptions<T extends Record<string, any>> {
+    initialValues?: Partial<T>;
+    onSubmit: (values: T) => void | Promise<void>;
+    onError?: (errors: Record<keyof T, string | undefined>) => void;
+    validateOnChange?: boolean;
+    validateOnBlur?: boolean;
+}
+interface FloatFormResult<T extends Record<string, any>> {
+    values: T;
+    errors: Partial<Record<keyof T, string>>;
+    touched: Partial<Record<keyof T, boolean>>;
+    isSubmitting: boolean;
+    isValid: boolean;
+    isDirty: boolean;
+    register: (name: keyof T) => {
+        value: any;
+        onChange: (e: React.ChangeEvent<any>) => void;
+        onBlur: (e: React.FocusEvent<any>) => void;
+        name: string;
+    };
+    setValue: (name: keyof T, value: any) => void;
+    setError: (name: keyof T, error: string | undefined) => void;
+    setTouched: (name: keyof T, touched?: boolean) => void;
+    reset: (values?: Partial<T>) => void;
+    handleSubmit: (e?: React.FormEvent) => Promise<void>;
+    validate: () => Promise<boolean>;
+    getFieldProps: (name: keyof T) => FieldState;
+}
+/**
+ * Powerful form handling with validation
+ * @example
+ * const form = useFloatForm({
+ *   initialValues: { email: '', password: '' },
+ *   onSubmit: async (values) => await login(values)
+ * });
+ */
+declare function useFloatForm<T extends Record<string, any>>(options: FloatFormOptions<T>): FloatFormResult<T>;
+declare const validators: {
+    required: (message?: string) => ValidationRule<any>;
+    email: (message?: string) => ValidationRule<string>;
+    minLength: (min: number, message?: string) => ValidationRule<string>;
+    maxLength: (max: number, message?: string) => ValidationRule<string>;
+    pattern: (regex: RegExp, message?: string) => ValidationRule<string>;
+    match: (field: string, message?: string) => ValidationRule<any>;
+};
+
+/**
+ * Float.js Async Hook
+ * Handle async operations with loading and error states
+ */
+interface AsyncState<T> {
+    data: T | undefined;
+    error: Error | undefined;
+    isLoading: boolean;
+    isSuccess: boolean;
+    isError: boolean;
+    isIdle: boolean;
+}
+interface FloatAsyncResult<T, Args extends any[]> extends AsyncState<T> {
+    execute: (...args: Args) => Promise<T | undefined>;
+    reset: () => void;
+    setData: (data: T) => void;
+}
+interface FloatAsyncOptions<T> {
+    /** Initial data */
+    initialData?: T;
+    /** Execute immediately on mount */
+    immediate?: boolean;
+    /** Retry count on error */
+    retryCount?: number;
+    /** Delay between retries (ms) */
+    retryDelay?: number;
+    /** Callback on success */
+    onSuccess?: (data: T) => void;
+    /** Callback on error */
+    onError?: (error: Error) => void;
+    /** Callback on settle (success or error) */
+    onSettled?: (data: T | undefined, error: Error | undefined) => void;
+}
+/**
+ * Execute async functions with loading/error states
+ * @example
+ * const { data, isLoading, execute } = useFloatAsync(
+ *   async (id) => await fetchUser(id),
+ *   { immediate: false }
+ * );
+ */
+declare function useFloatAsync<T, Args extends any[] = []>(asyncFn: (...args: Args) => Promise<T>, options?: FloatAsyncOptions<T>): FloatAsyncResult<T, Args>;
+/**
+ * Debounced async execution
+ */
+declare function useFloatDebounce<T, Args extends any[]>(asyncFn: (...args: Args) => Promise<T>, delay?: number, options?: FloatAsyncOptions<T>): FloatAsyncResult<T, Args>;
+/**
+ * Throttled async execution
+ */
+declare function useFloatThrottle<T, Args extends any[]>(asyncFn: (...args: Args) => Promise<T>, limit?: number, options?: FloatAsyncOptions<T>): FloatAsyncResult<T, Args>;
+
+/**
+ * Float.js Store Hook
+ * Lightweight global state management (like Zustand but simpler)
+ */
+type SetState<T> = (partial: Partial<T> | ((state: T) => Partial<T>)) => void;
+type GetState<T> = () => T;
+type Subscribe = (listener: () => void) => () => void;
+type Selector<T, U> = (state: T) => U;
+interface FloatStore<T> {
+    getState: GetState<T>;
+    setState: SetState<T>;
+    subscribe: Subscribe;
+    reset: () => void;
+}
+interface FloatStoreOptions<T> {
+    /** Persist state to localStorage */
+    persist?: string;
+    /** Custom equality function */
+    equals?: (a: any, b: any) => boolean;
+    /** Middleware */
+    middleware?: (set: SetState<T>, get: GetState<T>) => SetState<T>;
+}
+/**
+ * Create a global store
+ * @example
+ * const useStore = createFloatStore({ count: 0 });
+ *
+ * // In component
+ * const count = useStore(state => state.count);
+ */
+declare function createFloatStore<T extends object>(initialState: T | (() => T), options?: FloatStoreOptions<T>): {
+    (): T;
+    <U>(selector: Selector<T, U>): U;
+    getState: GetState<T>;
+    setState: SetState<T>;
+    subscribe: Subscribe;
+    reset: () => void;
+};
+/**
+ * Use a selector on an existing store
+ */
+declare function useFloatStore<T, U>(store: FloatStore<T>, selector: Selector<T, U>): U;
+declare const floatMiddleware: {
+    /**
+     * Log all state changes
+     */
+    logger: <T>(name?: string) => (set: SetState<T>, get: GetState<T>) => SetState<T>;
+    /**
+     * Add undo/redo capability
+     */
+    undoable: <T>(maxHistory?: number) => (set: SetState<T>, get: GetState<T>) => SetState<T>;
+    /**
+     * Debounce state updates
+     */
+    debounce: <T>(delay: number) => (set: SetState<T>, _get: GetState<T>) => SetState<T>;
+};
+/**
+ * Combine multiple stores
+ */
+declare function combineFloatStores<T extends Record<string, FloatStore<any>>>(stores: T): FloatStore<{
+    [K in keyof T]: ReturnType<T[K]['getState']>;
+}>;
+
+/**
+ * Float.js Welcome Page
+ * Shown when users first install the framework
+ */
+declare function generateWelcomePage(): string;
+
+/**
+ * Float.js - Ultra Modern Web Framework
+ *
+ * @packageDocumentation
+ */
+
+interface FloatConfig {
+    /** App directory (default: 'app') */
+    appDir?: string;
+    /** Base path for all routes */
+    basePath?: string;
+    /** Enable React strict mode */
+    reactStrictMode?: boolean;
+    /** Internationalization config */
+    i18n?: {
+        locales: string[];
+        defaultLocale: string;
+    };
+    /** Custom headers */
+    headers?: () => Promise<Array<{
+        source: string;
+        headers: Array<{
+            key: string;
+            value: string;
+        }>;
+    }>>;
+    /** Redirects */
+    redirects?: () => Promise<Array<{
+        source: string;
+        destination: string;
+        permanent: boolean;
+    }>>;
+    /** Environment variables to expose to client */
+    env?: Record<string, string>;
+    /** Experimental features */
+    experimental?: {
+        serverActions?: boolean;
+        ppr?: boolean;
+    };
+}
+interface Metadata {
+    title?: string | {
+        default: string;
+        template?: string;
+    };
+    description?: string;
+    keywords?: string[];
+    authors?: Array<{
+        name: string;
+        url?: string;
+    }>;
+    creator?: string;
+    publisher?: string;
+    robots?: string | {
+        index?: boolean;
+        follow?: boolean;
+        googleBot?: {
+            index?: boolean;
+            follow?: boolean;
+        };
+    };
+    openGraph?: {
+        title?: string;
+        description?: string;
+        url?: string;
+        siteName?: string;
+        images?: Array<{
+            url: string;
+            width?: number;
+            height?: number;
+            alt?: string;
+        }>;
+        locale?: string;
+        type?: 'website' | 'article' | 'book' | 'profile';
+    };
+    twitter?: {
+        card?: 'summary' | 'summary_large_image' | 'app' | 'player';
+        title?: string;
+        description?: string;
+        images?: string[];
+        creator?: string;
+    };
+    icons?: {
+        icon?: string | Array<{
+            url: string;
+            sizes?: string;
+        }>;
+        apple?: string | Array<{
+            url: string;
+            sizes?: string;
+        }>;
+    };
+    manifest?: string;
+    canonical?: string;
+}
+
+export { type BuildOptions, type BuildResult, type FloatConfig, Route as FloatRoute, type Metadata, VERSION, build, clearModuleCache, combineFloatStores, createFloatStore, floatMiddleware, generateWelcomePage, transformFile, transformSource, useFloatAsync, useFloatData, useFloatDebounce, useFloatForm, useFloatRouter, useFloatStore, useFloatThrottle, validators };