interview-widget 1.0.0 → 1.0.1

package/dist/components/interview/phases/transcription-animation.d.ts

@@ -0,0 +1,6 @@
+import { STTError } from '../../../services/stt';
+interface Props {
+    sttError: STTError | null;
+}
+export declare const TranscriptionAnimation: ({ sttError }: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/interview/proctoring/cheating-warning-modal.d.ts

@@ -0,0 +1,10 @@
+import { ViolationType } from '../../../types';
+interface CheatingWarningModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    warningCount: number;
+    violationType: ViolationType;
+    onDisqualify: () => void;
+}
+export declare function CheatingWarningModal({ isOpen, onClose, warningCount, violationType, onDisqualify, }: CheatingWarningModalProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/components/interview/proctoring/interview-proctoring.d.ts

@@ -0,0 +1,6 @@
+interface Props {
+    children: React.ReactNode;
+    onDisqualify?: (() => void) | undefined;
+}
+export declare const InterviewProctoring: ({ children, onDisqualify }: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/interview/question-display.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+import { InterviewQuestionData } from '../../types';
+interface QuestionDisplayProps {
+    question: InterviewQuestionData | null;
+    isLoading?: boolean;
+    className?: string;
+}
+declare const QuestionDisplay: React.FC<QuestionDisplayProps>;
+export default QuestionDisplay;

package/dist/components/media/audio-wave-visualizer.d.ts

@@ -0,0 +1,14 @@
+import { default as React } from 'react';
+type AudioWaveVisualizerProps = {
+    className?: string;
+    width?: number;
+    height?: number;
+    barWidth?: number;
+    gap?: number;
+    fftSize?: 256 | 512 | 1024 | 2048;
+    smoothingTimeConstant?: number;
+    mediaStream?: MediaStream;
+    startOnMount?: boolean;
+};
+declare const AudioWaveVisualizer: React.FC<AudioWaveVisualizerProps>;
+export default AudioWaveVisualizer;

package/dist/components/media/video-feed.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+interface VideoFeedProps {
+    className?: string;
+}
+declare const VideoFeed: React.FC<VideoFeedProps>;
+export default VideoFeed;

package/dist/components/modals/exit-confirmation-modal.d.ts

@@ -0,0 +1,7 @@
+interface Props {
+    confirmExitInterview: () => void;
+    isOpen: boolean;
+    onClose: () => void;
+}
+export declare const ExitConfirmationModal: ({ confirmExitInterview, isOpen, onClose, }: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/modals/hard-reload-warning.d.ts

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+interface Violation {
+    type: string;
+    severity: string;
+    details: {
+        action: string;
+        reason: string;
+    };
+}
+interface Props {
+    showHardReloadWarning: boolean;
+    logViolation: (violation: Violation) => void;
+    onContinue: () => void;
+}
+declare const HardReloadWarning: React.FC<Props>;
+export default HardReloadWarning;

package/dist/components/modals/onboarding-modal.d.ts

@@ -0,0 +1,8 @@
+import { default as React } from 'react';
+interface PermissionModalProps {
+    isOpen: boolean;
+    onStart: () => void;
+    onClose?: () => void;
+}
+declare const OnboardingModal: React.FC<PermissionModalProps>;
+export default OnboardingModal;

package/dist/components/timer/circular-timer.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+interface CircularTimerProps {
+    total: number;
+    remaining: number;
+    size?: number;
+    strokeWidth?: number;
+    className?: string;
+    showLabel?: boolean;
+}
+declare const CircularTimer: React.FC<CircularTimerProps>;
+export default CircularTimer;

package/dist/components/timer/timer-display.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+import { TimerState } from '../../services/timer/timer-service';
+interface TimerDisplayProps {
+    state: TimerState;
+    className?: string;
+    defaultTimers?: {
+        thinking?: number;
+        answering?: number;
+        editing?: number;
+    };
+}
+declare const TimerDisplay: React.FC<TimerDisplayProps>;
+export default TimerDisplay;

package/dist/components/ui/button.d.ts

@@ -0,0 +1,9 @@
+import { default as React, ButtonHTMLAttributes } from 'react';
+interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    variant?: "primary" | "secondary" | "outline" | "text" | "gradient";
+    size?: "sm" | "md" | "lg";
+    fullWidth?: boolean;
+    isLoading?: boolean;
+}
+declare const Button: React.FC<ButtonProps>;
+export default Button;

package/dist/components/ui/dialog.d.ts

@@ -0,0 +1,13 @@
+import { default as React, ReactNode } from 'react';
+interface DialogProps {
+    isOpen: boolean;
+    onClose: () => void;
+    children: ReactNode;
+    title?: string;
+    showCloseButton?: boolean;
+    closeOnOverlayClick?: boolean;
+    closeOnEscape?: boolean;
+    className?: string;
+}
+declare const Dialog: React.FC<DialogProps>;
+export default Dialog;

package/dist/components/ui/extended/styled-button.d.ts

@@ -0,0 +1,7 @@
+import { ButtonHTMLAttributes } from 'react';
+interface Props extends ButtonHTMLAttributes<HTMLButtonElement> {
+    children?: React.ReactNode;
+    loading?: boolean;
+}
+export declare const StyledButton: (props: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ui/input.d.ts

@@ -0,0 +1,8 @@
+import { default as React, InputHTMLAttributes } from 'react';
+interface InputProps extends InputHTMLAttributes<HTMLInputElement> {
+    label?: string;
+    error?: string;
+    fullWidth?: boolean;
+}
+declare const Input: React.FC<InputProps>;
+export default Input;

package/dist/components/ui/textarea.d.ts

@@ -0,0 +1,8 @@
+import { default as React, TextareaHTMLAttributes } from 'react';
+interface TextareaProps extends TextareaHTMLAttributes<HTMLTextAreaElement> {
+    label?: string;
+    error?: string;
+    fullWidth?: boolean;
+}
+declare const Textarea: React.FC<TextareaProps>;
+export default Textarea;

package/dist/context/index.d.ts

@@ -0,0 +1,2 @@
+export * from './interview-widget-context';
+export * from './proctoring-context';

package/dist/context/interview-widget-context.d.ts

@@ -0,0 +1,34 @@
+import { ReactNode } from 'react';
+import { InterviewWidgetConfig } from '../types';
+interface InterviewWidgetProviderProps {
+    config?: InterviewWidgetConfig;
+    children: ReactNode;
+}
+export declare function InterviewWidgetProvider({ config, children, }: InterviewWidgetProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useInterviewConfig(): InterviewWidgetConfig;
+/**
+ * Hook to access specific config sections
+ */
+export declare function useAPIConfig(): {
+    baseUrl?: string;
+    authToken?: string;
+    retryConfig?: {
+        attempts?: number;
+        backoff?: "fixed" | "exponential";
+        baseDelay?: number;
+    };
+};
+export declare function useUIConfig(): {
+    baseColor?: string;
+    borderRadius?: string;
+};
+export declare function useInterviewConfigSection(): NonNullable<InterviewWidgetConfig["interview"]>;
+export declare function useSTTConfig(): {
+    provider?: "groq" | "deepgram";
+    model?: "whisper-large-v3-turbo" | (string & {});
+    language?: "en";
+} | undefined;
+export declare function useTTSConfig(): {
+    provider?: "piper";
+} | undefined;
+export {};

package/dist/context/proctoring-context.d.ts

@@ -0,0 +1,17 @@
+import { default as React } from 'react';
+import { ViolationLogger } from '../types';
+export declare const ProctoringProvider: React.FC<{
+    children: React.ReactNode;
+}>;
+export declare const useProctoringStore: () => {
+    logViolations: ViolationLogger[];
+    totalViolations: number;
+    addViolation: (violation: ViolationLogger) => void;
+    clearViolations: () => void;
+};
+export declare const useViolations: () => ViolationLogger[];
+export declare const useTotalViolations: () => number;
+export declare const useProctoringActions: () => {
+    addViolation: (violation: ViolationLogger) => void;
+    clearViolations: () => void;
+};

package/dist/dev.d.ts

@@ -1 +0,0 @@
-

package/dist/hooks/index.d.ts

@@ -0,0 +1,11 @@
+export * from './use-api';
+export * from './use-dialog';
+export * from './use-full-screen';
+export * from './use-interview-api';
+export * from './use-keyboard-prevention';
+export * from './use-stt';
+export * from './use-tab-switch';
+export * from './use-text-selection-prevention';
+export * from './use-timer';
+export * from './use-tts';
+export * from './use-violation-logger';

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

@@ -0,0 +1,26 @@
+import { APIError, APIHookState } from '../types';
+type UseQueryAPIOptions<T> = {
+    immediate?: boolean;
+    enabled?: boolean;
+    onError?: (error: APIError) => void;
+    onSuccess?: (data: T) => void;
+    onSettled?: (data: T | null, error: APIError | null) => void;
+};
+type UseMutationAPIOptions<T> = {
+    onError?: (error: APIError) => void;
+    onSuccess?: (data: T) => void;
+    onSettled?: (data: T | null, error: APIError | null) => void;
+};
+/**
+ * Hook for GET requests (queries) - auto-executes and provides refetch
+ */
+export declare function useQueryAPI<T>(apiCall: () => Promise<T>, options?: UseQueryAPIOptions<T>): APIHookState<T> & {
+    refetch: () => Promise<void>;
+};
+/**
+ * Hook for mutations (POST/PUT/PATCH/DELETE) - manual execution with parameters
+ */
+export declare function useMutationAPI<T, P extends any[] = []>(apiCall: (...args: P) => Promise<T>, options?: UseMutationAPIOptions<T>): APIHookState<T> & {
+    execute: (...args: P) => Promise<void>;
+};
+export {};

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

@@ -0,0 +1,6 @@
+export declare const useDialog: (initialState?: boolean) => {
+    isOpen: boolean;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+};

package/dist/hooks/use-full-screen.d.ts

@@ -0,0 +1,17 @@
+interface FullscreenError {
+    name: string;
+    message: string;
+}
+interface UseFullScreenReturn {
+    isFullScreen: boolean;
+    toggleFullScreen: (element?: HTMLElement) => Promise<void>;
+    enterFullScreen: (element?: HTMLElement) => Promise<void>;
+    exitFullScreen: () => Promise<void>;
+    error: FullscreenError | null;
+}
+interface UseFullScreenOptions {
+    onError?: (error: FullscreenError) => void;
+    onFullScreenChange?: (isFullScreen: boolean) => void;
+}
+export declare const useFullScreen: (options?: UseFullScreenOptions) => UseFullScreenReturn;
+export {};

package/dist/hooks/use-interview-api.d.ts

@@ -0,0 +1,5 @@
+import { InterviewAPI } from '../services/api/interview-api';
+/**
+ *  Provides a configured InterviewAPI instance
+ */
+export declare function useInterviewAPI(): InterviewAPI;

package/dist/hooks/use-keyboard-prevention.d.ts

@@ -0,0 +1,2 @@
+import { Violation } from '../types';
+export declare const useKeyboardPrevention: (logViolation: (violation: Violation) => void) => void;

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

@@ -0,0 +1,20 @@
+import { STTConfig, STTError, STTRequest, STTResponse } from '../services/stt';
+export interface UseSTTReturn {
+    startRecording: (maxDuration?: number) => Promise<void>;
+    stopRecording: () => Promise<Blob>;
+    transcribe: (audioBlob: Blob, options?: Partial<STTRequest>) => Promise<STTResponse>;
+    cancelRecording: () => void;
+    isRecording: boolean;
+    isTranscribing: boolean;
+    transcript: string | null;
+    error: STTError | null;
+    audioBlob: Blob | null;
+}
+export interface UseSTTOptions {
+    config?: Partial<STTConfig>;
+    onStart?: () => void;
+    onStop?: () => void;
+    onTranscriptionComplete?: (result: STTResponse) => void;
+    onError?: (error: STTError) => void;
+}
+export declare const useSTT: (options?: UseSTTOptions) => UseSTTReturn;

package/dist/hooks/use-tab-switch.d.ts

@@ -0,0 +1,2 @@
+import { Violation } from '../types';
+export declare const useTabSwitchMonitor: (logViolation: (violation: Violation) => void) => void;

package/dist/hooks/use-text-selection-prevention.d.ts

@@ -0,0 +1 @@
+export declare const useTextSelectionPrevention: () => void;

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

@@ -0,0 +1,13 @@
+import { TimerService, TimerState, TimerConfig, TimerCallbacks } from '../services/timer/timer-service';
+export interface UseTimerOptions {
+    config?: Partial<TimerConfig>;
+    callbacks?: TimerCallbacks;
+}
+export interface UseTimerReturn {
+    state: TimerState;
+    startQuestion: () => void;
+    nextPhase: () => void;
+    completeInterview: () => void;
+    timerService: TimerService;
+}
+export declare function useTimer(options?: UseTimerOptions): UseTimerReturn;

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

@@ -0,0 +1,15 @@
+import { TTSConfig, TTSRequest } from '../services/tts';
+export interface UseTTSReturn {
+    speak: (text: string, options?: Partial<TTSRequest>) => Promise<void>;
+    stop: () => void;
+    isPlaying: boolean;
+    isLoading: boolean;
+    error: Error | null;
+}
+export interface UseTTSOptions {
+    config?: Partial<TTSConfig>;
+    onStart?: () => void;
+    onEnd?: () => void;
+    onError?: (error: Error) => void;
+}
+export declare const useTTS: (options?: UseTTSOptions) => UseTTSReturn;

package/dist/hooks/use-violation-logger.d.ts

@@ -0,0 +1,13 @@
+import { Violation, ViolationLogger } from '../types';
+interface ViolationLoggerProps {
+    onViolation?: (violation: ViolationLogger, violationCount: number) => void;
+    onEnd?: (reason: string, violationCount: number) => void;
+    maxViolations?: number;
+}
+export declare const useViolationLogger: ({ onViolation, onEnd: onExamEnd, maxViolations, }: ViolationLoggerProps) => {
+    logViolation: ({ type, severity, details }: Violation) => void;
+    onInterviewEnd: (reason: string) => void;
+    violationCount: number;
+    logList: ViolationLogger[];
+};
+export {};

package/dist/index.d.ts

@@ -1,14 +1,12 @@
-import { default as ChatWidget } from './ChatWidget';
-import { default as Message } from './Message';
-
-export { ChatWidget, Message };
+import { InterviewWidgetProvider } from './context/interview-widget-context';
+import { default as InterviewWidget } from './interview-widget';
 export * from './types';
-export { ChatWidget as default };
+export { InterviewWidget as default, InterviewWidget, InterviewWidgetProvider };
 declare global {
     interface Window {
-        ChatWidget: {
-            ChatWidget: typeof ChatWidget;
-            Message: typeof Message;
+        InterviewWidget: {
+            InterviewWidget: typeof InterviewWidget;
+            InterviewWidgetProvider: typeof InterviewWidgetProvider;
         };
         React: any;
         ReactDOM: any;

package/dist/interview-widget.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { InterviewWidgetProps } from './types';
+declare const InterviewWidget: React.FC<InterviewWidgetProps>;
+export default InterviewWidget;

package/dist/services/api/index.d.ts

@@ -0,0 +1,2 @@
+export { interviewAPI, InterviewAPI } from './interview-api';
+export type { APIError, APIErrorType, APIHookState } from '../../types';

package/dist/services/api/interview-api.d.ts

@@ -0,0 +1,23 @@
+import { InterviewQuestionPayload, InterviewQuestionResponse, InterviewWidgetConfig } from '../../types';
+declare class InterviewAPI {
+    private config;
+    constructor(config?: InterviewWidgetConfig["api"]);
+    /**
+     * Update configuration
+     */
+    updateConfig(config: InterviewWidgetConfig["api"]): void;
+    /**
+     * Get default headers for API requests
+     */
+    private getHeaders;
+    /**
+     * Get base URL from config with fallback
+     */
+    private getBaseUrl;
+    /**
+     * Get questions for an interview
+     */
+    generateQuestion({ interviewId, isInterviewDone, qnaId, question, answer, answerDuration, }: InterviewQuestionPayload): Promise<InterviewQuestionResponse>;
+}
+export declare const interviewAPI: InterviewAPI;
+export { InterviewAPI };

package/dist/services/stt/index.d.ts

@@ -0,0 +1 @@
+export { sttService, STTService, STTError, type STTConfig, type STTRequest, type STTResponse, type RecordingEvents, } from './stt-service';

package/dist/services/stt/stt-service.d.ts

@@ -0,0 +1,79 @@
+export interface STTConfig {
+    baseUrl?: string;
+    provider?: string;
+    model?: string;
+    language?: string;
+    authToken?: string;
+    includeTimestamps?: boolean;
+    temperature?: number;
+}
+export interface STTRequest {
+    audioBlob: Blob;
+    model?: string;
+    language?: string;
+    includeTimestamps?: boolean;
+    temperature?: number;
+}
+export interface STTResponse {
+    transcript: string;
+    confidence?: number;
+    language?: string;
+    duration?: number;
+}
+export interface RecordingEvents {
+    onStart?: () => void;
+    onStop?: () => void;
+    onDataAvailable?: (blob: Blob) => void;
+    onError?: (error: Error) => void;
+}
+export declare class STTError extends Error {
+    readonly code: string;
+    readonly recoverable: boolean;
+    constructor(message: string, code: string, recoverable?: boolean);
+}
+declare class STTService {
+    private config;
+    private mediaRecorder;
+    private audioChunks;
+    private recordingStream;
+    private autoStopTimeoutId;
+    constructor(config?: STTConfig);
+    /**
+     * Update STT configuration
+     */
+    updateConfig(config: Partial<STTConfig>): void;
+    /**
+     * Check if browser supports audio recording
+     */
+    isRecordingSupported(): boolean;
+    /**
+     * Start recording audio from user's microphone
+     */
+    startRecording(maxDuration?: number, events?: RecordingEvents): Promise<void>;
+    /**
+     * Stop recording and return the audio blob
+     */
+    stopRecording(): Promise<Blob>;
+    /**
+     * Transcribe audio blob using the STT API
+     */
+    transcribe(request: STTRequest): Promise<STTResponse>;
+    /**
+     * Cancel current recording without processing
+     */
+    cancelRecording(): void;
+    /**
+     * Check if currently recording
+     */
+    isRecording(): boolean;
+    /**
+     * Get supported MIME type for recording
+     */
+    private getSupportedMimeType;
+    /**
+     * Clean up recording resources
+     */
+    private cleanup;
+}
+export declare const sttService: STTService;
+export { STTService };

package/dist/services/timer/index.d.ts

@@ -0,0 +1,6 @@
+export { TimerPhase, TimerService } from './timer-service';
+export type { TimerCallbacks, TimerConfig, TimerState } from './timer-service';
+export { useTimer } from '../../hooks/use-timer';
+export type { UseTimerOptions, UseTimerReturn } from '../../hooks/use-timer';
+export { default as InterviewController } from '../../components/interview/interview-controller';
+export { default as TimerDisplay } from '../../components/timer/timer-display';

package/dist/services/timer/timer-service.d.ts

@@ -0,0 +1,82 @@
+/**
+ * TimerService - Time controller for interview phases
+ */
+export declare enum TimerPhase {
+    IDLE = "idle",
+    FETCHING_QUESTION = "fetching_question",
+    READING_QUESTION = "reading_question",
+    THINKING = "thinking",
+    ANSWERING = "answering",
+    TRANSCRIBING = "transcribing",
+    EDITING = "editing",
+    SUBMITTING = "submitting",
+    COMPLETED = "completed"
+}
+export interface TimerConfig {
+    thinkingDuration: number;
+    answeringDuration: number;
+    editingDuration: number;
+}
+export interface TimerState {
+    phase: TimerPhase;
+    currentPhaseTimeRemaining: number;
+    totalTimeElapsed: number;
+    currentQuestionNumber: number;
+}
+export interface TimerCallbacks {
+    onPhaseChange?: (phase: TimerPhase, state: TimerState) => void;
+    onTick?: (state: TimerState) => void;
+    onInterviewEnd?: () => void;
+}
+export declare class TimerService {
+    private config;
+    private state;
+    private phaseIntervalId;
+    private globalIntervalId;
+    callbacks: TimerCallbacks;
+    constructor(config?: Partial<TimerConfig>, callbacks?: TimerCallbacks);
+    /**
+     * Get current state
+     */
+    getState(): Readonly<TimerState>;
+    /**
+     * Start a new question cycle
+     */
+    startQuestion(): void;
+    /**
+     * Move to next phase
+     */
+    nextPhase(): void;
+    /**
+     * Manually complete the interview
+     */
+    completeInterview(): void;
+    /**
+     * Cleanup
+     */
+    destroy(): void;
+    /**
+     * Get duration for a phase
+     */
+    private getDurationForPhase;
+    /**
+     * Start global timer (runs continuously during entire interview for tracking)
+     */
+    private startGlobalTimer;
+    /**
+     * Stop global timer
+     */
+    private stopGlobalTimer;
+    /**
+     * Start phase timer (only for timed phases)
+     */
+    private startPhaseTimer;
+    /**
+     * Stop phase timer
+     */
+    private stopPhaseTimer;
+    /**
+     * Notify phase change
+     */
+    private notifyChange;
+}

package/dist/services/tts/index.d.ts

@@ -0,0 +1 @@
+export * from './tts-service';