@nuraly/lumenui 0.1.0 → 0.2.2

package/dist/src/components/chatbot/providers/mock-provider.d.ts

@@ -0,0 +1,154 @@
+/**
+ * @license
+ * Copyright 2023 Nuraly, Laabidi Aymen
+ * SPDX-License-Identifier: MIT
+ */
+import type { ChatbotProvider, ChatbotContext, ProviderCapabilities } from '../core/types.js';
+import type { ChatbotFile } from '../chatbot.types.js';
+export interface MockProviderConfig {
+    /**
+     * Response delay in milliseconds (simulates API latency)
+     */
+    delay?: number;
+    /**
+     * Enable streaming responses (character by character)
+     */
+    streaming?: boolean;
+    /**
+     * Streaming speed (characters per iteration)
+     */
+    streamingSpeed?: number;
+    /**
+     * Streaming interval in milliseconds
+     */
+    streamingInterval?: number;
+    /**
+     * Enable contextual responses (smarter responses based on keywords)
+     */
+    contextualResponses?: boolean;
+    /**
+     * Enable echo mode (echo back user's message)
+     */
+    echoMode?: boolean;
+    /**
+     * Custom responses to use instead of built-in ones
+     */
+    customResponses?: string[];
+    /**
+     * Error simulation rate (0-1, 0 = no errors, 1 = always error)
+     */
+    errorRate?: number;
+    /**
+     * Enable message history awareness
+     */
+    useHistory?: boolean;
+    /**
+     * Simulate tool calls before responding
+     */
+    simulateToolCalls?: boolean;
+    /**
+     * Tool names to simulate (default: ['search_web', 'get_weather', 'run_code'])
+     */
+    toolCallNames?: string[];
+    /**
+     * Delay per tool call in ms (default: 1500)
+     */
+    toolCallDelay?: number;
+}
+/**
+ * Mock Provider for demo and testing purposes.
+ * Simulates AI responses without requiring a real API.
+ *
+ * Features:
+ * - Configurable response delay
+ * - Streaming support (character-by-character)
+ * - Contextual responses based on keywords
+ * - Echo mode
+ * - Custom responses
+ * - Error simulation
+ * - Message history awareness
+ *
+ * @example
+ * ```typescript
+ * const provider = new MockProvider({
+ *   delay: 1000,
+ *   streaming: true,
+ *   contextualResponses: true
+ * });
+ *
+ * const controller = new ChatbotCoreController({
+ *   provider,
+ *   ui: callbacks
+ * });
+ * ```
+ */
+export declare class MockProvider implements ChatbotProvider {
+    readonly id = "mock-provider";
+    readonly name = "Mock Provider";
+    readonly capabilities: ProviderCapabilities;
+    private config;
+    private messageCount;
+    private connected;
+    /** Called when a tool/function call is detected */
+    onToolCall?: (name: string) => void;
+    /** Called when a tool/function call ends */
+    onToolCallEnd?: () => void;
+    constructor(config?: MockProviderConfig);
+    connect(_config?: any): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    sendMessage(text: string, context?: ChatbotContext): AsyncIterator<string>;
+    uploadFile(file: File): Promise<ChatbotFile>;
+    private determineFileType;
+    private generateResponse;
+    private getContextualResponse;
+    private getRandomResponse;
+    private streamResponse;
+    private delay;
+    /**
+     * Reset message count (useful for testing)
+     */
+    reset(): void;
+    /**
+     * Update configuration on the fly
+     */
+    updateConfig(config: Partial<MockProviderConfig>): void;
+    /**
+     * Get current configuration
+     */
+    getConfig(): Readonly<Required<MockProviderConfig>>;
+}
+/**
+ * Pre-configured mock providers for common scenarios
+ */
+export declare const MockProviders: {
+    /**
+     * Fast responses, no streaming
+     */
+    fast: () => MockProvider;
+    /**
+     * Realistic API simulation with streaming
+     */
+    realistic: () => MockProvider;
+    /**
+     * Slow responses for testing loading states
+     */
+    slow: () => MockProvider;
+    /**
+     * Echo mode for debugging
+     */
+    echo: () => MockProvider;
+    /**
+     * Streaming mode for demo
+     */
+    streaming: () => MockProvider;
+    /**
+     * Error simulation for testing error handling
+     */
+    unreliable: () => MockProvider;
+    /**
+     * Custom responses
+     */
+    custom: (responses: string[]) => MockProvider;
+};
+//# sourceMappingURL=mock-provider.d.ts.map

package/dist/src/components/chatbot/providers/mock-provider.js

@@ -0,0 +1,411 @@
+/**
+ * @license
+ * Copyright 2023 Nuraly, Laabidi Aymen
+ * SPDX-License-Identifier: MIT
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+import { ChatbotFileType } from '../chatbot.types.js';
+/**
+ * Mock responses for demo purposes
+ */
+const MOCK_RESPONSES = [
+    "That's an interesting question! Let me think about that...",
+    "I understand what you're asking. Here's what I think:",
+    "Great point! Based on what you've told me, I would suggest:",
+    "I'd be happy to help with that. Let me explain:",
+    "That's a common question. The answer is:",
+    "I see where you're coming from. Let me clarify:",
+    "Excellent question! Here's my perspective:",
+    "I can definitely help you with that. Consider this:",
+];
+const CONTEXTUAL_RESPONSES = {
+    hello: [
+        "Hello! 👋 How can I help you today?",
+        "Hi there! What can I do for you?",
+        "Hey! Great to see you. What's on your mind?",
+    ],
+    help: [
+        "I'm here to help! You can ask me anything. Try asking about features, getting started, or technical questions.",
+        "I can assist with various topics. What do you need help with?",
+        "Sure! I'm ready to help. What would you like to know?",
+    ],
+    bye: [
+        "Goodbye! Feel free to come back anytime! 👋",
+        "See you later! Have a great day!",
+        "Bye! It was nice chatting with you!",
+    ],
+    thanks: [
+        "You're welcome! Happy to help! 😊",
+        "Glad I could help!",
+        "Anytime! That's what I'm here for!",
+    ],
+    how: [
+        "Great question! Here's how it works: First, you need to understand the basics. Then, you can dive deeper into the specifics.",
+        "Let me explain the process step by step...",
+        "That's actually quite straightforward. Let me break it down for you:",
+    ],
+    what: [
+        "Good question! Let me explain what that means...",
+        "That refers to a concept that's important to understand. Here's the breakdown:",
+        "Interesting topic! Here's what you need to know:",
+    ],
+    why: [
+        "That's because of several factors. Let me explain the reasoning:",
+        "Great question! The main reason is that it provides better functionality and user experience.",
+        "There are multiple reasons for this. The primary one is:",
+    ],
+};
+/**
+ * Mock Provider for demo and testing purposes.
+ * Simulates AI responses without requiring a real API.
+ *
+ * Features:
+ * - Configurable response delay
+ * - Streaming support (character-by-character)
+ * - Contextual responses based on keywords
+ * - Echo mode
+ * - Custom responses
+ * - Error simulation
+ * - Message history awareness
+ *
+ * @example
+ * ```typescript
+ * const provider = new MockProvider({
+ *   delay: 1000,
+ *   streaming: true,
+ *   contextualResponses: true
+ * });
+ *
+ * const controller = new ChatbotCoreController({
+ *   provider,
+ *   ui: callbacks
+ * });
+ * ```
+ */
+export class MockProvider {
+    constructor(config = {}) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        this.id = 'mock-provider';
+        this.name = 'Mock Provider';
+        this.capabilities = {
+            streaming: true,
+            fileUpload: true,
+            modules: false,
+            functions: true,
+        };
+        this.messageCount = 0;
+        this.connected = false;
+        this.config = {
+            delay: (_a = config.delay) !== null && _a !== void 0 ? _a : 800,
+            streaming: (_b = config.streaming) !== null && _b !== void 0 ? _b : false,
+            streamingSpeed: (_c = config.streamingSpeed) !== null && _c !== void 0 ? _c : 3,
+            streamingInterval: (_d = config.streamingInterval) !== null && _d !== void 0 ? _d : 50,
+            contextualResponses: (_e = config.contextualResponses) !== null && _e !== void 0 ? _e : true,
+            echoMode: (_f = config.echoMode) !== null && _f !== void 0 ? _f : false,
+            customResponses: (_g = config.customResponses) !== null && _g !== void 0 ? _g : [],
+            errorRate: (_h = config.errorRate) !== null && _h !== void 0 ? _h : 0,
+            useHistory: (_j = config.useHistory) !== null && _j !== void 0 ? _j : true,
+            simulateToolCalls: (_k = config.simulateToolCalls) !== null && _k !== void 0 ? _k : false,
+            toolCallNames: (_l = config.toolCallNames) !== null && _l !== void 0 ? _l : ['search_web', 'get_weather', 'run_code'],
+            toolCallDelay: (_m = config.toolCallDelay) !== null && _m !== void 0 ? _m : 1500,
+        };
+    }
+    connect(_config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Simulate connection delay
+            yield this.delay(100);
+            this.connected = true;
+            console.log('🤖 Mock Provider connected');
+        });
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.connected = false;
+            console.log('🤖 Mock Provider disconnected');
+        });
+    }
+    isConnected() {
+        return this.connected;
+    }
+    sendMessage(text, context) {
+        return __asyncGenerator(this, arguments, function* sendMessage_1() {
+            var _a, e_1, _b, _c;
+            var _d, _e;
+            this.messageCount++;
+            // Simulate error
+            if (Math.random() < this.config.errorRate) {
+                yield __await(this.delay(this.config.delay / 2));
+                throw new Error('Simulated API error for testing');
+            }
+            // Simulate API delay
+            yield __await(this.delay(this.config.delay));
+            // Simulate tool calls if enabled
+            if (this.config.simulateToolCalls) {
+                const tools = this.config.toolCallNames;
+                const numCalls = 1 + Math.floor(Math.random() * Math.min(tools.length, 3));
+                for (let i = 0; i < numCalls; i++) {
+                    const toolName = tools[i % tools.length];
+                    (_d = this.onToolCall) === null || _d === void 0 ? void 0 : _d.call(this, toolName);
+                    yield __await(this.delay(this.config.toolCallDelay));
+                    (_e = this.onToolCallEnd) === null || _e === void 0 ? void 0 : _e.call(this);
+                }
+            }
+            // Generate response
+            const response = this.generateResponse(text, context);
+            // Stream response or return all at once
+            if (this.config.streaming) {
+                try {
+                    for (var _f = true, _g = __asyncValues(this.streamResponse(response)), _h; _h = yield __await(_g.next()), _a = _h.done, !_a; _f = true) {
+                        _c = _h.value;
+                        _f = false;
+                        const chunk = _c;
+                        yield yield __await(chunk);
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (!_f && !_a && (_b = _g.return)) yield __await(_b.call(_g));
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }
+            else {
+                yield yield __await(response);
+            }
+        });
+    }
+    uploadFile(file) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Simulate upload delay
+            yield this.delay(this.config.delay);
+            // Simulate error
+            if (Math.random() < this.config.errorRate) {
+                throw new Error('Simulated file upload error for testing');
+            }
+            // Determine file type
+            const mimeType = file.type || 'application/octet-stream';
+            const fileType = this.determineFileType(mimeType);
+            // Generate mock file ID
+            const fileId = `mock-file-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+            console.log(`📎 Mock Provider: File uploaded - ${file.name} (${file.size} bytes) - ID: ${fileId}`);
+            // Return ChatbotFile
+            const chatbotFile = {
+                id: fileId,
+                name: file.name,
+                size: file.size,
+                type: fileType,
+                mimeType: mimeType,
+                url: URL.createObjectURL(file), // Create temporary URL for preview
+                previewUrl: fileType === 'image' ? URL.createObjectURL(file) : undefined,
+                uploadProgress: 100,
+                metadata: {
+                    provider: 'mock',
+                    uploadedAt: new Date().toISOString(),
+                },
+            };
+            return chatbotFile;
+        });
+    }
+    determineFileType(mimeType) {
+        if (mimeType.startsWith('image/'))
+            return ChatbotFileType.Image;
+        if (mimeType.startsWith('video/'))
+            return ChatbotFileType.Video;
+        if (mimeType.startsWith('audio/'))
+            return ChatbotFileType.Audio;
+        if (mimeType.startsWith('application/pdf') ||
+            mimeType.includes('document') ||
+            mimeType.includes('text'))
+            return ChatbotFileType.Document;
+        if (mimeType.includes('zip') ||
+            mimeType.includes('rar') ||
+            mimeType.includes('tar'))
+            return ChatbotFileType.Archive;
+        if (mimeType.includes('javascript') ||
+            mimeType.includes('json') ||
+            mimeType.includes('xml'))
+            return ChatbotFileType.Code;
+        return ChatbotFileType.Unknown;
+    }
+    generateResponse(text, context) {
+        var _a, _b;
+        const allMessages = (context === null || context === void 0 ? void 0 : context.messages) || [];
+        const lastUserIndex = (_a = [...allMessages].map((m, i) => ({ m, i }))
+            .reverse()
+            .find(({ m }) => m.sender === 'user' && !!m.text)) === null || _a === void 0 ? void 0 : _a.i;
+        const effectiveText = (typeof lastUserIndex === 'number' && ((_b = allMessages[lastUserIndex]) === null || _b === void 0 ? void 0 : _b.text))
+            ? allMessages[lastUserIndex].text
+            : text;
+        // Echo mode
+        if (this.config.echoMode) {
+            return `You said: "${effectiveText}"`;
+        }
+        // Custom responses (highest priority after echo mode)
+        if (this.config.customResponses.length > 0) {
+            // Use messageCount - 1 because messageCount was already incremented in sendMessage
+            const index = (this.messageCount - 1) % this.config.customResponses.length;
+            return this.config.customResponses[index];
+        }
+        // Contextual responses
+        if (this.config.contextualResponses) {
+            const contextualResponse = this.getContextualResponse(effectiveText);
+            if (contextualResponse) {
+                return contextualResponse;
+            }
+        }
+        // History-aware responses: always anchor to the latest message, optionally weave prior context
+        if (this.config.useHistory && allMessages.length > 0 && typeof lastUserIndex === 'number') {
+            const prevUser = [...allMessages]
+                .slice(0, lastUserIndex)
+                .reverse()
+                .find(m => m.sender === 'user' && !!m.text);
+            if (prevUser && prevUser.text) {
+                return `Great point about "${String(effectiveText).substring(0, 60)}". Considering your earlier message about "${String(prevUser.text).substring(0, 30)}...", ${this.getRandomResponse()}`;
+            }
+            return `Regarding "${String(effectiveText).substring(0, 60)}", ${this.getRandomResponse()}`;
+        }
+        // Default random response anchored to latest
+        return `Regarding "${String(effectiveText).substring(0, 60)}", ${this.getRandomResponse()}`;
+    }
+    getContextualResponse(text) {
+        const lowerText = text.toLowerCase();
+        // Check for keywords
+        for (const [keyword, responses] of Object.entries(CONTEXTUAL_RESPONSES)) {
+            if (lowerText.includes(keyword)) {
+                const randomIndex = Math.floor(Math.random() * responses.length);
+                return responses[randomIndex];
+            }
+        }
+        return null;
+    }
+    getRandomResponse() {
+        const randomIndex = Math.floor(Math.random() * MOCK_RESPONSES.length);
+        return MOCK_RESPONSES[randomIndex];
+    }
+    streamResponse(text) {
+        return __asyncGenerator(this, arguments, function* streamResponse_1() {
+            let currentText = '';
+            const words = text.split(' ');
+            for (let i = 0; i < words.length; i++) {
+                const word = words[i];
+                currentText += (i > 0 ? ' ' : '') + word;
+                yield yield __await(currentText);
+                // Wait between words
+                if (i < words.length - 1) {
+                    yield __await(this.delay(this.config.streamingInterval));
+                }
+            }
+        });
+    }
+    delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    /**
+     * Reset message count (useful for testing)
+     */
+    reset() {
+        this.messageCount = 0;
+    }
+    /**
+     * Update configuration on the fly
+     */
+    updateConfig(config) {
+        Object.assign(this.config, config);
+    }
+    /**
+     * Get current configuration
+     */
+    getConfig() {
+        return Object.assign({}, this.config);
+    }
+}
+/**
+ * Pre-configured mock providers for common scenarios
+ */
+export const MockProviders = {
+    /**
+     * Fast responses, no streaming
+     */
+    fast: () => new MockProvider({
+        delay: 300,
+        streaming: false,
+        contextualResponses: true,
+    }),
+    /**
+     * Realistic API simulation with streaming
+     */
+    realistic: () => new MockProvider({
+        delay: 1200,
+        streaming: true,
+        streamingInterval: 50,
+        contextualResponses: true,
+        useHistory: true,
+    }),
+    /**
+     * Slow responses for testing loading states
+     */
+    slow: () => new MockProvider({
+        delay: 3000,
+        streaming: false,
+    }),
+    /**
+     * Echo mode for debugging
+     */
+    echo: () => new MockProvider({
+        delay: 500,
+        echoMode: true,
+    }),
+    /**
+     * Streaming mode for demo
+     */
+    streaming: () => new MockProvider({
+        delay: 800,
+        streaming: true,
+        streamingSpeed: 2,
+        streamingInterval: 30,
+    }),
+    /**
+     * Error simulation for testing error handling
+     */
+    unreliable: () => new MockProvider({
+        delay: 1000,
+        errorRate: 0.3, // 30% error rate
+    }),
+    /**
+     * Custom responses
+     */
+    custom: (responses) => new MockProvider({
+        delay: 800,
+        customResponses: responses,
+    }),
+};
+//# sourceMappingURL=mock-provider.js.map