@uraiagent/react 0.0.1

package/dist/helpers/MessageHandler.d.ts

@@ -0,0 +1,78 @@
+import { ProgressEventType, AgentResponseUI, ConfirmationEvent, FollowUpProps, HandoffPayloadType, Message, Meta, UserMessageProps } from '../interfaces';
+export type State = {
+    current_message: null | UserMessageProps;
+    progress_msg: null | string;
+    progress_event: null | ProgressEventType;
+    last_server_message_id: null | string;
+    messages: Message[];
+    meta: Meta;
+    logo: string;
+    client_state: Record<string, unknown>;
+};
+type Listener<T = State> = (value: T) => void;
+type UpdaterFunction<T = State> = (old_value: T) => T;
+export declare class ChatController {
+    listeners: Set<Listener<State>>;
+    private state;
+    private startSettleTimer;
+    private clearSettleTimer;
+    notify: () => void;
+    unSubscribe: (listener: Listener) => void;
+    subscribe: (listener: Listener) => () => void;
+    getSnapshot: () => State;
+    reset: () => void;
+    genId: (len?: number) => string;
+    isLoading: () => boolean;
+    setState: (newValue: State | UpdaterFunction) => void;
+    setStateUpdater: (updater: (draft: State) => void) => void;
+    select: <KT extends keyof State>(key: KT) => State[KT];
+    setProgress: (event: ProgressEventType | null, msg?: string | null) => void;
+    settle: () => void;
+    setLastServerMessageId: (_id: string | null) => void;
+    /** Bulk-load history messages without triggering loading state. */
+    loadMessages: (history: Array<{
+        id: string;
+        role: "user" | "agent";
+        text: string;
+        createdAt: string;
+        senderName?: string;
+        senderAvatarUrl?: string;
+        type?: string;
+        uiComponent?: {
+            componentType: string;
+            componentId?: string;
+            data?: {
+                structure?: Record<string, unknown>;
+                state?: Record<string, unknown>;
+                source?: Record<string, unknown>;
+                [k: string]: unknown;
+            };
+        };
+    }>) => void;
+    /** Optimistically add the user's message and mark as loading. */
+    appendUserMessage: (message: string) => string;
+    /** Add a complete agent message (non-streaming). */
+    appendAgentMessageFull: (id: string, text: string, senderName?: string, senderAvatarUrl?: string) => void;
+    /** Append a streaming chunk to the current in-progress agent message. */
+    appendAgentMessage: (text: string) => void;
+    /**
+     * Append a streaming chunk identified by a stable server-side message id.
+     * This is the preferred method for streaming — it does not rely on
+     * current_message and always finds or creates the right bubble.
+     */
+    appendStreamingChunk: (id: string, text: string, senderName?: string, senderAvatarUrl?: string) => void;
+    handleHandoff: (payload: HandoffPayloadType) => void;
+    handleFollowUp: (payload: FollowUpProps) => void;
+    handleConfirmation: (payload: ConfirmationEvent) => void;
+    handleUiEvent: (response: AgentResponseUI) => void;
+    /**
+     * Merge a state patch into an already-rendered widget message (server `message.update`
+     * or optimistic local update) so it re-renders its resolved look (e.g. an approval that
+     * hides its buttons). Looks up the message by id and merges into the widget's state.
+     */
+    patchMessage: (messageId: string, statePatch: Record<string, unknown>) => void;
+    private getAgentMessage;
+    private appendExistingMessage;
+    private addNewAgentMessage;
+}
+export {};

package/dist/hooks/index.d.ts

@@ -0,0 +1,11 @@
+export * from './useAsyncFn.ts';
+export * from './useAudioRecord.ts';
+export * from './useMountedState';
+export * from './useScrollTo';
+export * from './useToggle';
+export * from './useVote';
+export * from './useCanSend';
+export * from './useChatLoading';
+export * from './useSendMessage';
+export * from './useChatState';
+export * from './useToast';

package/dist/hooks/useAsyncFn.d.ts

@@ -0,0 +1,23 @@
+import { DependencyList } from 'react';
+import { FunctionReturningPromise, PromiseType } from '../interfaces';
+export type AsyncState<T> = {
+    loading: boolean;
+    error?: undefined;
+    value?: undefined;
+} | {
+    loading: true;
+    error?: Error | undefined;
+    value?: T;
+} | {
+    loading: false;
+    error: Error;
+    value?: undefined;
+} | {
+    loading: false;
+    error?: undefined;
+    value: T;
+};
+type StateFromFunctionReturningPromise<T extends FunctionReturningPromise> = AsyncState<PromiseType<ReturnType<T>>>;
+export type AsyncFnReturn<T extends FunctionReturningPromise = FunctionReturningPromise> = [StateFromFunctionReturningPromise<T>, T];
+export declare function useAsyncFn<T extends FunctionReturningPromise>(fn: T, deps?: DependencyList, initialState?: StateFromFunctionReturningPromise<T>): AsyncFnReturn<T>;
+export {};

package/dist/hooks/useAudioRecord.d.ts

@@ -0,0 +1,27 @@
+export interface recorderControls {
+    startRecording: () => void;
+    stopRecording: () => void;
+    togglePauseResume: () => void;
+    recordingBlob?: Blob;
+    isRecording: boolean;
+    isPaused: boolean;
+    recordingTime: number;
+    mediaRecorder?: MediaRecorder;
+}
+export type MediaAudioTrackConstraints = Pick<MediaTrackConstraints, "deviceId" | "groupId" | "autoGainControl" | "channelCount" | "echoCancellation" | "noiseSuppression" | "sampleRate" | "sampleSize">;
+/**
+ * @returns Controls for the recording. Details of returned controls are given below
+ *
+ * @param `audioTrackConstraints`: Takes a {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackSettings#instance_properties_of_audio_tracks subset} of `MediaTrackConstraints` that apply to the audio track
+ * @param `onNotAllowedOrFound`: A method that gets called when the getUserMedia promise is rejected. It receives the DOMException as its input.
+ *
+ * @details `startRecording`: Calling this method would result in the recording to start. Sets `isRecording` to true
+ * @details `stopRecording`: This results in a recording in progress being stopped and the resulting audio being present in `recordingBlob`. Sets `isRecording` to false
+ * @details `togglePauseResume`: Calling this method would pause the recording if it is currently running or resume if it is paused. Toggles the value `isPaused`
+ * @details `recordingBlob`: This is the recording blob that is created after `stopRecording` has been called
+ * @details `isRecording`: A boolean value that represents whether a recording is currently in progress
+ * @details `isPaused`: A boolean value that represents whether a recording in progress is paused
+ * @details `recordingTime`: Number of seconds that the recording has gone on. This is updated every second
+ * @details `mediaRecorder`: The current mediaRecorder in use
+ */
+export declare const useAudioRecorder: (audioTrackConstraints?: MediaAudioTrackConstraints, onNotAllowedOrFound?: (exception: DOMException) => any, mediaRecorderOptions?: MediaRecorderOptions) => recorderControls;

package/dist/hooks/useCanSend.d.ts

@@ -0,0 +1,6 @@
+export declare function useCanSend({ input }: {
+    input?: string;
+}): {
+    canSend: boolean;
+    cantSendReason: "disconnected" | "loading" | "empty";
+};

package/dist/hooks/useChatLoading.d.ts

@@ -0,0 +1 @@
+export declare function useChatLoading(): boolean;

package/dist/hooks/useChatState.d.ts

@@ -0,0 +1 @@
+export declare function useChatState(): import('../helpers/MessageHandler').State;

package/dist/hooks/useDocumentDirection.d.ts

@@ -0,0 +1,7 @@
+type Dir = "rtl" | "ltr";
+export declare function useDocumentDirection(): {
+    rtl: boolean;
+    ltr: boolean;
+    direction: Dir;
+};
+export {};

package/dist/hooks/useMountedState.d.ts

@@ -0,0 +1 @@
+export declare function useMountedState(): () => boolean;

package/dist/hooks/useOutsideClick.d.ts

@@ -0,0 +1 @@
+export declare const useOutsideClick: (callback: () => void, ref: any) => void;

package/dist/hooks/useScrollTo.d.ts

@@ -0,0 +1,2 @@
+import { RefObject } from 'react';
+export declare const useScrollToPercentage: (elementRef: RefObject<HTMLElement>) => [(percentageX: number, percentageY: number) => void];

package/dist/hooks/useSendMessage.d.ts

@@ -0,0 +1,3 @@
+export declare function useSendMessage(): {
+    send: (message: string) => Promise<void>;
+};

package/dist/hooks/useToast.d.ts

@@ -0,0 +1,44 @@
+import { ToastActionElement, ToastProps } from '../../builder/form/ui/toast';
+import * as React from "react";
+type ToasterToast = ToastProps & {
+    id: string;
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    action?: ToastActionElement;
+};
+declare const actionTypes: {
+    readonly ADD_TOAST: "ADD_TOAST";
+    readonly UPDATE_TOAST: "UPDATE_TOAST";
+    readonly DISMISS_TOAST: "DISMISS_TOAST";
+    readonly REMOVE_TOAST: "REMOVE_TOAST";
+};
+type ActionType = typeof actionTypes;
+type Action = {
+    type: ActionType["ADD_TOAST"];
+    toast: ToasterToast;
+} | {
+    type: ActionType["UPDATE_TOAST"];
+    toast: Partial<ToasterToast>;
+} | {
+    type: ActionType["DISMISS_TOAST"];
+    toastId?: ToasterToast["id"];
+} | {
+    type: ActionType["REMOVE_TOAST"];
+    toastId?: ToasterToast["id"];
+};
+interface State {
+    toasts: ToasterToast[];
+}
+export declare const reducer: (state: State, action: Action) => State;
+type Toast = Omit<ToasterToast, "id">;
+declare function toast({ ...props }: Toast): {
+    id: string;
+    dismiss: () => void;
+    update: (props: ToasterToast) => void;
+};
+declare function useToast(): {
+    toast: typeof toast;
+    dismiss: (toastId?: string) => void;
+    toasts: ToasterToast[];
+};
+export { useToast, toast };

package/dist/hooks/useToggle.d.ts

@@ -0,0 +1,2 @@
+import { Dispatch, SetStateAction } from 'react';
+export declare function useToggle(defaultValue?: boolean): [boolean, () => void, Dispatch<SetStateAction<boolean>>];

package/dist/hooks/useTrigger.d.ts

@@ -0,0 +1 @@
+export declare const useTrigger: (selector?: string, toggle?: () => void) => void;

package/dist/hooks/useVote.d.ts

@@ -0,0 +1,2 @@
+export declare function useUpvote(id: string): import('./useAsyncFn').AsyncFnReturn<() => Promise<void>>;
+export declare function useDownvote(id: string): import('./useAsyncFn').AsyncFnReturn<() => Promise<void>>;