@nuraly/lumenui 0.2.1 → 0.3.2

package/dist/src/components/chatbot/core/event-bus.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @license
+ * Copyright 2023 Nuraly, Laabidi Aymen
+ * SPDX-License-Identifier: MIT
+ */
+/**
+ * Simple event bus for internal event management
+ * Used by the core controller to emit events for plugins and internal communication
+ */
+export declare class EventBus {
+    private listeners;
+    /**
+     * Subscribe to an event
+     * @param event - Event name to subscribe to
+     * @param handler - Function to call when event is emitted
+     * @returns Unsubscribe function
+     */
+    on(event: string, handler: Function): () => void;
+    /**
+     * Subscribe to an event only once
+     * @param event - Event name to subscribe to
+     * @param handler - Function to call when event is emitted
+     */
+    once(event: string, handler: Function): void;
+    /**
+     * Unsubscribe from an event
+     * @param event - Event name to unsubscribe from
+     * @param handler - Handler to remove
+     */
+    off(event: string, handler: Function): void;
+    /**
+     * Emit an event
+     * @param event - Event name to emit
+     * @param data - Data to pass to handlers
+     */
+    emit(event: string, data?: any): void;
+    /**
+     * Remove all listeners for an event or all events
+     * @param event - Optional event name. If not provided, removes all listeners
+     */
+    removeAllListeners(event?: string): void;
+    /**
+     * Get the number of listeners for an event
+     * @param event - Event name
+     * @returns Number of listeners
+     */
+    listenerCount(event: string): number;
+    /**
+     * Get all event names that have listeners
+     * @returns Array of event names
+     */
+    eventNames(): string[];
+}
+//# sourceMappingURL=event-bus.d.ts.map

package/dist/src/components/chatbot/core/event-bus.js

@@ -0,0 +1,102 @@
+/**
+ * @license
+ * Copyright 2023 Nuraly, Laabidi Aymen
+ * SPDX-License-Identifier: MIT
+ */
+/**
+ * Simple event bus for internal event management
+ * Used by the core controller to emit events for plugins and internal communication
+ */
+export class EventBus {
+    constructor() {
+        this.listeners = new Map();
+    }
+    /**
+     * Subscribe to an event
+     * @param event - Event name to subscribe to
+     * @param handler - Function to call when event is emitted
+     * @returns Unsubscribe function
+     */
+    on(event, handler) {
+        if (!this.listeners.has(event)) {
+            this.listeners.set(event, new Set());
+        }
+        this.listeners.get(event).add(handler);
+        // Return unsubscribe function
+        return () => {
+            var _a, _b;
+            (_a = this.listeners.get(event)) === null || _a === void 0 ? void 0 : _a.delete(handler);
+            if (((_b = this.listeners.get(event)) === null || _b === void 0 ? void 0 : _b.size) === 0) {
+                this.listeners.delete(event);
+            }
+        };
+    }
+    /**
+     * Subscribe to an event only once
+     * @param event - Event name to subscribe to
+     * @param handler - Function to call when event is emitted
+     */
+    once(event, handler) {
+        const onceHandler = (...args) => {
+            handler(...args);
+            this.off(event, onceHandler);
+        };
+        this.on(event, onceHandler);
+    }
+    /**
+     * Unsubscribe from an event
+     * @param event - Event name to unsubscribe from
+     * @param handler - Handler to remove
+     */
+    off(event, handler) {
+        var _a;
+        (_a = this.listeners.get(event)) === null || _a === void 0 ? void 0 : _a.delete(handler);
+    }
+    /**
+     * Emit an event
+     * @param event - Event name to emit
+     * @param data - Data to pass to handlers
+     */
+    emit(event, data) {
+        const handlers = this.listeners.get(event);
+        if (handlers) {
+            handlers.forEach(handler => {
+                try {
+                    handler(data);
+                }
+                catch (error) {
+                    console.error(`Error in event handler for "${event}":`, error);
+                }
+            });
+        }
+    }
+    /**
+     * Remove all listeners for an event or all events
+     * @param event - Optional event name. If not provided, removes all listeners
+     */
+    removeAllListeners(event) {
+        if (event) {
+            this.listeners.delete(event);
+        }
+        else {
+            this.listeners.clear();
+        }
+    }
+    /**
+     * Get the number of listeners for an event
+     * @param event - Event name
+     * @returns Number of listeners
+     */
+    listenerCount(event) {
+        var _a;
+        return ((_a = this.listeners.get(event)) === null || _a === void 0 ? void 0 : _a.size) || 0;
+    }
+    /**
+     * Get all event names that have listeners
+     * @returns Array of event names
+     */
+    eventNames() {
+        return Array.from(this.listeners.keys());
+    }
+}
+//# sourceMappingURL=event-bus.js.map

package/dist/src/components/chatbot/core/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @license
+ * Copyright 2023 Nuraly, Laabidi Aymen
+ * SPDX-License-Identifier: MIT
+ */
+export { ChatbotCoreController } from './chatbot-core.controller.js';
+export { EventBus } from './event-bus.js';
+export { StateHandler, MessageHandler, ThreadHandler, FileHandler, ModuleHandler, SuggestionHandler } from './handlers/index.js';
+export { ProviderService, ValidationService, StorageService, PluginService } from './services/index.js';
+export type { ChatbotState, ChatbotUICallbacks, ChatbotContext, SendMessageOptions, ValidationResult, ChatbotCoreConfig, ProviderCapabilities, ProviderConfig, ChatbotProvider, ChatbotStorage, ChatbotPlugin, ChatbotEvents } from './types.js';
+export { ValidationError } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/components/chatbot/core/index.js

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright 2023 Nuraly, Laabidi Aymen
+ * SPDX-License-Identifier: MIT
+ */
+// Core controller
+export { ChatbotCoreController } from './chatbot-core.controller.js';
+// Event bus
+export { EventBus } from './event-bus.js';
+// Handlers (domain operations)
+export { StateHandler, MessageHandler, ThreadHandler, FileHandler, ModuleHandler, SuggestionHandler } from './handlers/index.js';
+// Services (infrastructure)
+export { ProviderService, ValidationService, StorageService, PluginService } from './services/index.js';
+export { ValidationError } from './types.js';
+//# sourceMappingURL=index.js.map

package/dist/src/components/chatbot/core/types.d.ts

@@ -0,0 +1,403 @@
+/**
+ * @license
+ * Copyright 2023 Nuraly, Laabidi Aymen
+ * SPDX-License-Identifier: MIT
+ */
+import type { ChatbotMessage, ChatbotThread, ChatbotModule, ChatbotFile, ChatbotSuggestion, ChatbotValidationRule, ChatbotArtifact } from '../chatbot.types.js';
+/**
+ * Core chatbot state (pure data, no UI)
+ */
+export interface ChatbotState {
+    messages: ChatbotMessage[];
+    threads: ChatbotThread[];
+    modules?: ChatbotModule[];
+    selectedModules: string[];
+    uploadedFiles: ChatbotFile[];
+    suggestions: ChatbotSuggestion[];
+    isTyping: boolean;
+    isProcessing: boolean;
+    statusText?: string;
+    currentThreadId?: string;
+    metadata: Record<string, any>;
+}
+/**
+ * UI callbacks that the core controller will invoke
+ * These are injected from the UI layer (Lit, React, Vue, etc.)
+ */
+export interface ChatbotUICallbacks {
+    /**
+     * Called when state changes (for UI synchronization)
+     */
+    onStateChange?: (state: Readonly<ChatbotState>) => void;
+    /**
+     * Called when typing indicator should start
+     */
+    onTypingStart?: () => void;
+    /**
+     * Called when typing indicator should end
+     */
+    onTypingEnd?: () => void;
+    /**
+     * Called when processing starts (e.g., sending message to provider)
+     */
+    onProcessingStart?: () => void;
+    /**
+     * Called when processing ends
+     */
+    onProcessingEnd?: () => void;
+    /**
+     * Called when status text changes (e.g., tool/function call names)
+     */
+    onStatusTextChange?: (text: string | undefined) => void;
+    /**
+     * Show notification to user
+     */
+    showNotification?: (message: string, type: 'info' | 'error' | 'success' | 'warning') => void;
+    /**
+     * Request user confirmation (returns true if confirmed)
+     */
+    requestUserConfirmation?: (message: string) => Promise<boolean>;
+    /**
+     * Open file dialog and return selected files
+     */
+    openFileDialog?: () => Promise<File[]>;
+    /**
+     * Show file preview
+     */
+    showFilePreview?: (file: ChatbotFile) => void;
+    /**
+     * Focus the input field
+     */
+    focusInput?: () => void;
+    /**
+     * Scroll to bottom of messages
+     */
+    scrollToBottom?: () => void;
+    /**
+     * Scroll to a specific message
+     */
+    scrollToMessage?: (messageId: string) => void;
+    /**
+     * Custom message rendering (optional)
+     */
+    renderMessage?: (message: ChatbotMessage) => any;
+    /**
+     * Custom suggestion rendering (optional)
+     */
+    renderSuggestion?: (suggestion: ChatbotSuggestion) => any;
+}
+/**
+ * Context passed to providers when sending messages
+ */
+export interface ChatbotContext {
+    messages: ChatbotMessage[];
+    currentThread?: ChatbotThread;
+    selectedModules: string[];
+    metadata: Record<string, any>;
+    uploadedFiles?: ChatbotFile[];
+}
+/**
+ * Options for sending a message
+ */
+export interface SendMessageOptions {
+    files?: ChatbotFile[];
+    metadata?: Record<string, any>;
+    skipValidation?: boolean;
+    threadId?: string;
+}
+/**
+ * Validation result
+ */
+export interface ValidationResult {
+    isValid: boolean;
+    errors: string[];
+    warnings?: string[];
+}
+/**
+ * Validation error
+ */
+export declare class ValidationError extends Error {
+    errors: string[];
+    constructor(errors: string[]);
+}
+/**
+ * Core chatbot configuration
+ */
+export interface ChatbotCoreConfig {
+    /**
+     * Provider for AI/backend integration
+     */
+    provider?: ChatbotProvider;
+    /**
+     * Storage for persistence
+     */
+    storage?: ChatbotStorage;
+    /**
+     * UI callbacks (injected from UI layer)
+     */
+    ui?: ChatbotUICallbacks;
+    /**
+     * Enable file upload functionality
+     */
+    enableFileUpload?: boolean;
+    /**
+     * Enable thread/conversation management
+     */
+    enableThreads?: boolean;
+    /**
+     * Enable module selection
+     */
+    enableModules?: boolean;
+    /**
+     * Maximum number of messages to keep in memory
+     */
+    maxMessages?: number;
+    /**
+     * Maximum file size in bytes
+     */
+    maxFileSize?: number;
+    /**
+     * Maximum number of files
+     */
+    maxFiles?: number;
+    /**
+     * Allowed file types (MIME types)
+     */
+    allowedFileTypes?: string[];
+    /**
+     * Custom validation rules
+     */
+    validators?: ChatbotValidationRule[];
+    /**
+     * Plugins to register
+     */
+    plugins?: ChatbotPlugin[];
+    /**
+     * Initial messages
+     */
+    initialMessages?: ChatbotMessage[];
+    /**
+     * Initial threads
+     */
+    initialThreads?: ChatbotThread[];
+    /**
+     * Initial suggestions (shown before any API response)
+     */
+    initialSuggestions?: ChatbotSuggestion[];
+    /**
+     * Custom metadata
+     */
+    metadata?: Record<string, any>;
+    /**
+     * Auto-save to storage interval (ms)
+     */
+    autoSaveInterval?: number;
+    /**
+     * Enable debug logging
+     */
+    debug?: boolean;
+}
+/**
+ * Provider capabilities
+ */
+export interface ProviderCapabilities {
+    streaming: boolean;
+    fileUpload: boolean;
+    modules: boolean;
+    functions: boolean;
+    imageGeneration?: boolean;
+    voiceInput?: boolean;
+}
+/**
+ * Provider configuration
+ */
+export interface ProviderConfig {
+    apiKey?: string;
+    apiUrl?: string;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    [key: string]: any;
+}
+/**
+ * Provider interface for AI/backend integration
+ */
+export interface ChatbotProvider {
+    /**
+     * Unique provider identifier
+     */
+    readonly id: string;
+    /**
+     * Provider name
+     */
+    readonly name: string;
+    /**
+     * Provider capabilities
+     */
+    readonly capabilities: ProviderCapabilities;
+    /**
+     * Connect/initialize the provider
+     */
+    connect(config: ProviderConfig): Promise<void>;
+    /**
+     * Disconnect/cleanup the provider
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Check if provider is connected
+     */
+    isConnected(): boolean;
+    /**
+     * Send message and get streaming response
+     */
+    sendMessage(text: string, context: ChatbotContext): AsyncIterator<string>;
+    /**
+     * Get available modules (if supported)
+     */
+    getAvailableModules?(): Promise<ChatbotModule[]>;
+    /**
+     * Call a module/function (if supported)
+     */
+    callModule?(moduleId: string, params: any): Promise<any>;
+    /**
+     * Upload file (if supported)
+     */
+    uploadFile?(file: File, context?: ChatbotContext): Promise<ChatbotFile>;
+    /**
+     * Error handler
+     */
+    onError?(error: Error): void;
+}
+/**
+ * Storage interface for persistence
+ */
+export interface ChatbotStorage {
+    /**
+     * Save state to storage
+     */
+    save(key: string, data: any): Promise<void>;
+    /**
+     * Load state from storage
+     */
+    load(key: string): Promise<any>;
+    /**
+     * Remove data from storage
+     */
+    remove(key: string): Promise<void>;
+    /**
+     * Clear all storage
+     */
+    clear(): Promise<void>;
+    /**
+     * Check if key exists
+     */
+    has(key: string): Promise<boolean>;
+}
+/**
+ * Plugin interface for extensibility
+ */
+export interface ChatbotPlugin {
+    /**
+     * Unique plugin identifier
+     */
+    readonly id: string;
+    /**
+     * Plugin name
+     */
+    readonly name: string;
+    /**
+     * Plugin version
+     */
+    readonly version: string;
+    /**
+     * Called when plugin is registered
+     */
+    onInit?(controller: any): void;
+    /**
+     * Called when plugin is destroyed
+     */
+    onDestroy?(): void;
+    /**
+     * Called when a user message is sent
+     */
+    onMessageSent?(message: ChatbotMessage): void | Promise<void>;
+    /**
+     * Called when a bot message is received
+     */
+    onMessageReceived?(message: ChatbotMessage): void | Promise<void>;
+    /**
+     * Called before sending message to provider (can transform)
+     */
+    beforeSend?(text: string): string | Promise<string>;
+    /**
+     * Called after receiving message from provider (can transform)
+     */
+    afterReceive?(text: string): string | Promise<string>;
+    /**
+     * Called when state changes
+     */
+    onStateChange?(state: Readonly<ChatbotState>): void;
+    /**
+     * Called on errors
+     */
+    onError?(error: Error): void;
+    /**
+     * Declare HTML-like block tags this plugin understands, e.g., [FLIGHT]...[/FLIGHT]
+     * PluginService/Provider will use these to tokenize the stream and hand off complete blocks.
+     */
+    htmlTags?: Array<{
+        /** Logical name for the tag */
+        name: string;
+        /** Opening marker (literal) */
+        open: string;
+        /** Closing marker (literal) */
+        close: string;
+    }>;
+    /**
+     * Optional renderer for a completed HTML-like block found during streaming.
+     * Should return a trusted HTML string (plugin is responsible for safety) or empty string to skip.
+     */
+    renderHtmlBlock?(name: string, content: string): string;
+    /**
+     * Optional custom renderer for the artifact panel content area.
+     * When provided, replaces the default content rendering (code, JSON pretty-print, etc.)
+     * while the header (language badge, title, copy/close) remains default.
+     * Should return a trusted HTML string.
+     */
+    renderArtifactContent?(artifact: ChatbotArtifact): string;
+}
+/**
+ * Events emitted by the core controller
+ */
+export interface ChatbotEvents {
+    'state:changed': ChatbotState;
+    'message:added': ChatbotMessage;
+    'message:updated': ChatbotMessage;
+    'message:deleted': string;
+    'message:sent': ChatbotMessage;
+    'message:received': ChatbotMessage;
+    'typing:start': void;
+    'typing:end': void;
+    'processing:start': void;
+    'processing:end': void;
+    'file:uploaded': ChatbotFile;
+    'file:removed': string;
+    'thread:created': ChatbotThread;
+    'thread:selected': ChatbotThread;
+    'thread:deleted': string;
+    'thread:renamed': {
+        threadId: string;
+        title: string;
+    };
+    'thread:bookmarked': {
+        threadId: string;
+        bookmarked: boolean;
+    };
+    'module:selected': string[];
+    'provider:connected': string;
+    'provider:disconnected': string;
+    'provider:error': Error;
+    'validation:error': ValidationError;
+    'error': Error;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/components/chatbot/core/types.js

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2023 Nuraly, Laabidi Aymen
+ * SPDX-License-Identifier: MIT
+ */
+/**
+ * Validation error
+ */
+export class ValidationError extends Error {
+    constructor(errors) {
+        super(errors.join(', '));
+        this.errors = errors;
+        this.name = 'ValidationError';
+    }
+}
+//# sourceMappingURL=types.js.map

package/dist/src/components/chatbot/locales/locale-codes.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The locale code that templates in this source code are written in.
+ */
+export declare const sourceLocale = "en";
+/**
+ * The other locale codes that this application is localized into. Sorted
+ * lexicographically.
+ */
+export declare const targetLocales: readonly ["ar", "fr"];
+/**
+ * All valid project locale codes. Sorted lexicographically.
+ */
+export declare const allLocales: readonly ["ar", "en", "fr"];
+//# sourceMappingURL=locale-codes.d.ts.map

package/dist/src/components/chatbot/locales/locale-codes.js

@@ -0,0 +1,23 @@
+// Do not modify this file by hand!
+// Re-generate this file by running lit-localize.
+/**
+ * The locale code that templates in this source code are written in.
+ */
+export const sourceLocale = `en`;
+/**
+ * The other locale codes that this application is localized into. Sorted
+ * lexicographically.
+ */
+export const targetLocales = [
+    `ar`,
+    `fr`,
+];
+/**
+ * All valid project locale codes. Sorted lexicographically.
+ */
+export const allLocales = [
+    `ar`,
+    `en`,
+    `fr`,
+];
+//# sourceMappingURL=locale-codes.js.map

package/dist/src/components/chatbot/plugins/analytics-plugin.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright 2023 Nuraly, Laabidi Aymen
+ * SPDX-License-Identifier: MIT
+ */
+import type { ChatbotPlugin } from '../core/types.js';
+import type { ChatbotMessage } from '../chatbot.types.js';
+/**
+ * Analytics plugin - tracks chatbot usage and events
+ */
+export declare class AnalyticsPlugin implements ChatbotPlugin {
+    readonly id = "analytics";
+    readonly name = "Analytics Plugin";
+    readonly version = "1.0.0";
+    private trackEvent;
+    constructor(trackEvent: (event: string, data?: any) => void);
+    onInit(): void;
+    onDestroy(): void;
+    onMessageSent(message: ChatbotMessage): void;
+    onMessageReceived(message: ChatbotMessage): void;
+    onError(error: Error): void;
+}
+//# sourceMappingURL=analytics-plugin.d.ts.map