@melony/react 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,165 @@
+import * as React$1 from 'react';
+import React__default, { ReactNode } from 'react';
+import { ClientState, Client } from 'melony/client';
+import { Role, Event, UINode } from 'melony';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+
+interface User {
+    id: string;
+    email: string;
+    name: string;
+    picture?: string;
+}
+interface Message {
+    role: Role;
+    content: Event[];
+    runId?: string;
+    threadId?: string;
+}
+interface ThreadData {
+    id: string;
+    title?: string;
+    updatedAt?: Date | string;
+}
+interface StarterPrompt {
+    label: string;
+    prompt: string;
+    icon?: React.ReactNode;
+}
+interface AuthService {
+    getMe: () => Promise<User | null>;
+    login: () => void;
+    logout: () => Promise<void>;
+    getToken: () => string | null;
+}
+interface ThreadService {
+    getThreads: () => Promise<ThreadData[]>;
+    createThread?: () => Promise<string>;
+    deleteThread: (id: string) => Promise<void>;
+    getEvents: (threadId: string) => Promise<Event[]>;
+}
+
+interface MelonyContextValue extends ClientState {
+    messages: Message[];
+    sendEvent: (event: Event, options?: {
+        runId?: string;
+        state?: Record<string, any>;
+    }) => Promise<void>;
+    clear: () => void;
+    client: Client;
+}
+declare const MelonyContext: React__default.Context<MelonyContextValue | undefined>;
+interface MelonyProviderProps {
+    children: ReactNode;
+    client: Client;
+}
+declare const MelonyProvider: React__default.FC<MelonyProviderProps>;
+
+interface AuthContextValue {
+    user: User | null;
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    login: () => void;
+    logout: () => void;
+    getToken: () => string | null;
+}
+declare const AuthContext: React__default.Context<AuthContextValue | undefined>;
+interface AuthProviderProps {
+    children: ReactNode;
+    service: AuthService;
+}
+declare const AuthProvider: React__default.FC<AuthProviderProps>;
+
+interface ThreadContextValue {
+    threads: ThreadData[];
+    activeThreadId: string | null;
+    isLoading: boolean;
+    error: Error | null;
+    selectThread: (threadId: string) => void;
+    createThread: () => Promise<string>;
+    deleteThread: (threadId: string) => Promise<void>;
+    refreshThreads: () => Promise<void>;
+    threadEvents: Event[];
+    threadMessages: Message[];
+    isLoadingEvents: boolean;
+}
+declare const ThreadContext: React__default.Context<ThreadContextValue | undefined>;
+interface ThreadProviderProps {
+    children: ReactNode;
+    service: ThreadService;
+    initialThreadId?: string;
+}
+declare const ThreadProvider: React__default.FC<ThreadProviderProps>;
+
+declare const useMelony: () => MelonyContextValue;
+
+declare const useAuth: () => AuthContextValue;
+
+declare const useThreads: () => ThreadContextValue;
+
+declare function Thread({ className, placeholder, starterPrompts, onStarterPromptClick, }: {
+    className?: string;
+    placeholder?: string;
+    starterPrompts?: StarterPrompt[];
+    onStarterPromptClick?: (prompt: string) => void;
+}): react_jsx_runtime.JSX.Element;
+
+interface ComposerProps {
+    value: string;
+    onChange: (value: string) => void;
+    onSubmit: (e?: React__default.FormEvent) => void;
+    placeholder?: string;
+    isLoading?: boolean;
+    className?: string;
+}
+declare function Composer({ value, onChange, onSubmit, placeholder, isLoading, className, }: ComposerProps): react_jsx_runtime.JSX.Element;
+
+interface ChatPopupProps {
+    title?: string;
+    placeholder?: string;
+    starterPrompts?: StarterPrompt[];
+    defaultOpen?: boolean;
+}
+declare function ChatPopup({ title, placeholder, starterPrompts, defaultOpen, }: ChatPopupProps): react_jsx_runtime.JSX.Element;
+
+interface ChatSidebarProps {
+    title?: string;
+    placeholder?: string;
+    starterPrompts?: StarterPrompt[];
+    className?: string;
+}
+declare function ChatSidebar({ title, placeholder, starterPrompts, className, }: ChatSidebarProps): react_jsx_runtime.JSX.Element;
+
+interface ChatFullProps {
+    title?: string;
+    placeholder?: string;
+    starterPrompts?: StarterPrompt[];
+    className?: string;
+}
+declare function ChatFull({ title, placeholder, starterPrompts, className, }: ChatFullProps): react_jsx_runtime.JSX.Element;
+
+interface ThreadListProps {
+    className?: string;
+    emptyState?: React$1.ReactNode;
+    onThreadSelect?: (threadId: string) => void;
+}
+declare const ThreadList: React$1.FC<ThreadListProps>;
+
+interface AccountDialogProps {
+    className?: string;
+    variant?: "default" | "destructive" | "outline" | "secondary" | "ghost" | "link";
+    size?: "default" | "sm" | "lg" | "icon";
+}
+declare const AccountDialog: React$1.FC<AccountDialogProps>;
+
+interface UIRendererProps {
+    node: UINode;
+}
+/**
+ * Maps UINode types to refined React elements aligned with shadcn.
+ * UI is built via elements always starting with a card element as a root.
+ * Children are always rendered elements, never raw strings.
+ */
+declare function UIRenderer({ node }: UIRendererProps): react_jsx_runtime.JSX.Element;
+
+export { AccountDialog, type AccountDialogProps, AuthContext, type AuthContextValue, AuthProvider, type AuthProviderProps, type AuthService, ChatFull, type ChatFullProps, ChatPopup, type ChatPopupProps, ChatSidebar, type ChatSidebarProps, Composer, MelonyContext, type MelonyContextValue, MelonyProvider, type MelonyProviderProps, type Message, type StarterPrompt, Thread, ThreadContext, type ThreadContextValue, type ThreadData, ThreadList, type ThreadListProps, ThreadProvider, type ThreadProviderProps, type ThreadService, UIRenderer, type UIRendererProps, type User, useAuth, useMelony, useThreads };