reactolith 1.0.19

package/dist/index.d.ts

@@ -0,0 +1,236 @@
+import { Root } from 'react-dom/client';
+import React, { ElementType, PropsWithChildren, ReactNode } from 'react';
+import { Href } from '@react-types/shared';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+
+type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+type Handler$1<Args extends readonly unknown[]> = (...args: Args) => void;
+type RouterEventMap = {
+    "nav:started": [input: URL | string, init: RequestInit, pushState: boolean];
+    "nav:ended": [
+        input: URL | string,
+        init: RequestInit,
+        pushState: boolean,
+        response: Response,
+        html: string,
+        finalUrl: string
+    ];
+    "render:success": [
+        input: URL | string,
+        init: RequestInit,
+        pushState: boolean,
+        response: Response,
+        html: string,
+        finalUrl: string
+    ];
+    "render:failed": [
+        input: URL | string,
+        init: RequestInit,
+        pushState: boolean,
+        response: Response,
+        html: string,
+        finalUrl: string
+    ];
+};
+declare class Router {
+    private readonly app;
+    private readonly fetch;
+    private listeners;
+    constructor(app: App, doc?: Document, fetchImpl?: FetchLike);
+    private ensureSet;
+    protected emit<K extends keyof RouterEventMap>(type: K, ...args: RouterEventMap[K]): void;
+    on<K extends keyof RouterEventMap>(type: K, handler: Handler$1<RouterEventMap[K]>): () => void;
+    off<K extends keyof RouterEventMap>(type: K, handler: Handler$1<RouterEventMap[K]>): void;
+    visit(input: URL | string, init?: RequestInit, pushState?: boolean): Promise<{
+        result: boolean;
+        response: Response;
+        html: string;
+        finalUrl: string;
+    }>;
+    onClick(event: MouseEvent): Promise<void>;
+    onSubmit(event: SubmitEvent): Promise<void>;
+    navigate(path: Href): Promise<void>;
+}
+
+type MercureConfig = {
+    hubUrl: string;
+    withCredentials?: boolean;
+};
+declare class App {
+    readonly element: HTMLElement;
+    readonly router: Router;
+    readonly component: ElementType;
+    mercureConfig?: MercureConfig;
+    private readonly appProvider;
+    private readonly selector;
+    private readonly root;
+    private readonly doc;
+    constructor(component: ElementType, appProvider?: ElementType<PropsWithChildren<{
+        app: App;
+    }>>, selector?: ((doc: Document) => HTMLElement | null) | string, root?: Root, doc?: Document, fetchImp?: FetchLike);
+    render(document: string | Document): boolean;
+    renderElement(element: HTMLElement): void;
+    unmount(): void;
+}
+
+type Handler<Args extends readonly unknown[]> = (...args: Args) => void;
+type MercureEventMap = {
+    "sse:connected": [url: string];
+    "sse:disconnected": [url: string];
+    "sse:message": [event: MessageEvent, html: string];
+    "render:success": [event: MessageEvent, html: string];
+    "render:failed": [event: MessageEvent, html: string];
+    "refetch:started": [event: MessageEvent];
+    "refetch:success": [event: MessageEvent, html: string];
+    "refetch:failed": [event: MessageEvent, error: Error];
+    "sse:error": [error: Event];
+};
+type MercureOptions = {
+    /** The Mercure hub URL to connect to */
+    hubUrl: string;
+    /** Optional: Last-Event-ID for reconnection */
+    lastEventId?: string;
+    /** Optional: Whether to include credentials (cookies) */
+    withCredentials?: boolean;
+};
+declare class Mercure {
+    private readonly app;
+    private eventSource;
+    private listeners;
+    private currentUrl;
+    private options;
+    private routerUnsubscribe;
+    constructor(app: App);
+    private ensureSet;
+    protected emit<K extends keyof MercureEventMap>(type: K, ...args: MercureEventMap[K]): void;
+    on<K extends keyof MercureEventMap>(type: K, handler: Handler<MercureEventMap[K]>): () => void;
+    off<K extends keyof MercureEventMap>(type: K, handler: Handler<MercureEventMap[K]>): void;
+    /**
+     * Subscribe to a Mercure hub for real-time updates.
+     * Automatically subscribes to the current pathname and re-subscribes on route changes.
+     */
+    subscribe(options: MercureOptions): void;
+    /**
+     * Connect to EventSource with current pathname as topic
+     */
+    private connectToCurrentPath;
+    /**
+     * Close the SSE connection
+     */
+    close(): void;
+    /**
+     * Check if currently connected
+     */
+    get connected(): boolean;
+    /**
+     * Get the current connection URL
+     */
+    get url(): string | null;
+    /**
+     * Get the last event ID (useful for reconnection)
+     */
+    get lastEventId(): string | undefined;
+}
+
+declare const ReactolithComponent: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLElement> & {
+    element?: HTMLElement;
+    component: React.ElementType;
+} & React.RefAttributes<HTMLElement>>;
+
+declare function useApp(): App;
+declare const AppProvider: React.FC<PropsWithChildren<{
+    app: App;
+}>>;
+
+type RenderFailedPayload = {
+    /** whatever your router emits, kept as unknown to avoid tight coupling */
+    input: unknown;
+    init: unknown;
+    pushState: unknown;
+    response: unknown;
+    html: unknown;
+    finalUrl: unknown;
+};
+type RenderError = RenderFailedPayload & {
+    /** increments for every error so consumers can re-open dialogs */
+    id: number;
+    /** when the error was captured */
+    timestamp: number;
+};
+type RouterContextType = {
+    router: Router;
+    loading: boolean;
+    /** last render error (if any) */
+    lastError: RenderError | null;
+    /** clear currently shown error (e.g., when dialog is closed) */
+    clearError: () => void;
+};
+declare function RouterProvider({ children }: {
+    children: React.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function useRouter(): RouterContextType;
+
+/**
+ * Subscribe to a Mercure topic and receive live JSON data updates.
+ *
+ * @template T - The type of data expected from the topic
+ * @param topic - The Mercure topic to subscribe to
+ * @param initialValue - The initial value before any updates
+ * @returns The current value from the topic
+ *
+ * @example
+ * ```tsx
+ * // Simple usage with type inference
+ * const count = useMercureTopic('/notifications/count', 0);
+ *
+ * // With explicit type
+ * const status = useMercureTopic<'online' | 'offline'>('/status', 'offline');
+ *
+ * // With complex type
+ * interface Stats { visitors: number; sales: number; }
+ * const stats = useMercureTopic<Stats>('/stats', { visitors: 0, sales: 0 });
+ * ```
+ */
+declare function useMercureTopic<T>(topic: string, initialValue: T): T;
+
+/**
+ * Generic hook for subscribing to a Mercure topic and receiving raw message data.
+ * This is a low-level hook that handles EventSource connection management.
+ *
+ * @param topic - The Mercure topic to subscribe to
+ * @param onMessage - Callback when a message is received
+ * @param onError - Optional callback when an error occurs
+ *
+ * @internal This is a low-level hook. Use useMercureTopic or MercureLive instead.
+ */
+declare function useMercureEventSource(topic: string, onMessage: (data: string) => void, onError?: (error: Event) => void): void;
+
+/**
+ * Component that subscribes to a Mercure topic and renders HTML updates.
+ *
+ * Use this for partial page updates that should be reflected across all pages,
+ * like sidebars, notification areas, or live feeds.
+ *
+ * @example
+ * ```tsx
+ * <MercureLive topic="/sidebar">
+ *   <sidebar-component>Initial content</sidebar-component>
+ * </MercureLive>
+ * ```
+ *
+ * Backend can push updates to this region:
+ * ```php
+ * $update = new Update('/sidebar', $sidebarHtml);
+ * $hub->publish($update);
+ * ```
+ */
+interface MercureLiveProps {
+    /** The Mercure topic to subscribe to */
+    topic: string;
+    /** Initial content to display before any updates */
+    children: ReactNode;
+}
+declare function MercureLive({ topic, children }: MercureLiveProps): react_jsx_runtime.JSX.Element;
+
+export { App, AppProvider, Mercure, MercureLive, ReactolithComponent, Router, RouterProvider, useApp, useMercureEventSource, useMercureTopic, useRouter };
+export type { MercureConfig, MercureLiveProps, MercureOptions };