@rimori/client 2.5.32 → 2.5.33

package/dist/fromRimori/EventBus.js

@@ -1,20 +1,12 @@
-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());
-    });
-};
 export class EventBusHandler {
+    listeners = new Map();
+    responseResolvers = new Map();
+    static instance = null;
+    debugEnabled = false;
+    evName = '';
+    generatedIds = new Map(); // Map<id, timestamp>
+    cleanupInterval = null;
     constructor() {
-        this.listeners = new Map();
-        this.responseResolvers = new Map();
-        this.debugEnabled = false;
-        this.evName = '';
-        this.generatedIds = new Map(); // Map<id, timestamp>
-        this.cleanupInterval = null;
         this.startIdCleanup();
     }
     /**
@@ -187,7 +179,7 @@ export class EventBusHandler {
             const blackListedEventIds = [];
             //To allow event communication inside the same plugin the sender needs to be ignored but the events still need to be checked for the same event just reaching the subscriber to prevent infinite loops
             const finalIgnoreSender = !topic.startsWith('self.') ? [sender] : [];
-            const listener = this.on(topic, (data) => __awaiter(this, void 0, void 0, function* () {
+            const listener = this.on(topic, async (data) => {
                 if (blackListedEventIds.includes(data.eventId)) {
                     // console.log("BLACKLISTED EVENT ID", data.eventId);
                     return;
@@ -196,9 +188,9 @@ export class EventBusHandler {
                 if (blackListedEventIds.length > 100) {
                     blackListedEventIds.shift();
                 }
-                const response = typeof handler === 'function' ? yield handler(data) : handler;
+                const response = typeof handler === 'function' ? await handler(data) : handler;
                 this.emit(sender, topic, response, data.eventId);
-            }), finalIgnoreSender);
+            }, finalIgnoreSender);
             this.logIfDebug(`Added respond listener ` + sender + ' to topic ' + topic, { listener, sender });
             return {
                 off: () => listener.off(),
@@ -221,7 +213,7 @@ export class EventBusHandler {
         let listener = undefined;
         const wrapper = (event) => {
             handler(event);
-            listener === null || listener === void 0 ? void 0 : listener.off();
+            listener?.off();
         };
         listener = this.on(topic, wrapper);
         this.logIfDebug(`Added once listener ` + topic, { listener, topic });
@@ -255,17 +247,15 @@ export class EventBusHandler {
      * @param data - The data of the event.
      * @returns A promise that resolves to the event.
      */
-    request(sender, topic, data, aiSessionToken) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.validateTopic(topic)) {
-                this.logAndThrowError(true, `Invalid topic: ` + topic);
-            }
-            const event = this.createEvent(sender, topic, data || {}, undefined, aiSessionToken);
-            this.logIfDebug(`Requesting data from ` + topic, { event });
-            return new Promise((resolve) => {
-                this.responseResolvers.set(event.eventId, (value) => resolve(value));
-                this.emitInternal(sender, topic, data || {}, event.eventId, true, aiSessionToken);
-            });
+    async request(sender, topic, data, aiSessionToken) {
+        if (!this.validateTopic(topic)) {
+            this.logAndThrowError(true, `Invalid topic: ` + topic);
+        }
+        const event = this.createEvent(sender, topic, data || {}, undefined, aiSessionToken);
+        this.logIfDebug(`Requesting data from ` + topic, { event });
+        return new Promise((resolve) => {
+            this.responseResolvers.set(event.eventId, (value) => resolve(value));
+            this.emitInternal(sender, topic, data || {}, event.eventId, true, aiSessionToken);
         });
     }
     /**
@@ -336,5 +326,4 @@ export class EventBusHandler {
         }
     }
 }
-EventBusHandler.instance = null;
 export const EventBus = EventBusHandler.getInstance();

package/dist/plugin/CommunicationHandler.js

@@ -1,24 +1,16 @@
-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());
-    });
-};
 import { PostgrestClient } from '@supabase/postgrest-js';
 import { EventBus } from '../fromRimori/EventBus';
 export class RimoriCommunicationHandler {
+    pluginId;
+    port = null;
+    queryParams = {};
+    supabase = null;
+    rimoriInfo = null;
+    isMessageChannelReady = false;
+    pendingRequests = [];
+    updateCallbacks = new Set();
     constructor(pluginId, standalone) {
         this.pluginId = pluginId;
-        this.port = null;
-        this.queryParams = {};
-        this.supabase = null;
-        this.rimoriInfo = null;
-        this.isMessageChannelReady = false;
-        this.pendingRequests = [];
-        this.updateCallbacks = new Set();
         this.getClient = this.getClient.bind(this);
         //no need to forward messages to parent in standalone mode or worker context
         if (standalone)
@@ -69,9 +61,8 @@ export class RimoriCommunicationHandler {
             };
             // Forward plugin events to parent (only after MessageChannel is ready)
             EventBus.on('*', (ev) => {
-                var _a;
                 if (ev.sender === this.pluginId && !ev.topic.startsWith('self.')) {
-                    (_a = this.port) === null || _a === void 0 ? void 0 : _a.postMessage({ event: ev });
+                    this.port?.postMessage({ event: ev });
                 }
             });
             // Listen for updates from rimori-main (data changes, token refresh, etc.)
@@ -129,9 +120,8 @@ export class RimoriCommunicationHandler {
         return this.queryParams[key] || null;
     }
     getSupabase(url, key, token) {
-        var _a;
         return new PostgrestClient(`${url}/rest/v1`, {
-            schema: (_a = this.rimoriInfo) === null || _a === void 0 ? void 0 : _a.dbSchema,
+            schema: this.rimoriInfo?.dbSchema,
             headers: {
                 apikey: key,
                 Authorization: `Bearer ${token}`,
@@ -139,69 +129,66 @@ export class RimoriCommunicationHandler {
             },
         });
     }
-    getClient() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Return cached client if valid
-            if (this.supabase && this.rimoriInfo && this.rimoriInfo.expiration > new Date()) {
-                return { supabase: this.supabase, info: this.rimoriInfo };
-            }
-            // If MessageChannel is not ready yet, queue the request
-            if (!this.isMessageChannelReady) {
+    async getClient() {
+        // Return cached client if valid
+        if (this.supabase && this.rimoriInfo && this.rimoriInfo.expiration > new Date()) {
+            return { supabase: this.supabase, info: this.rimoriInfo };
+        }
+        // If MessageChannel is not ready yet, queue the request
+        if (!this.isMessageChannelReady) {
+            return new Promise((resolve) => {
+                this.pendingRequests.push(async () => {
+                    const result = await this.getClient();
+                    resolve(result);
+                });
+            });
+        }
+        // If we have rimoriInfo from MessageChannel init, use it directly
+        if (this.rimoriInfo && this.supabase) {
+            return { supabase: this.supabase, info: this.rimoriInfo };
+        }
+        // Fallback: request from parent
+        if (!this.rimoriInfo) {
+            if (typeof WorkerGlobalScope !== 'undefined') {
+                // In worker context, send request via self.postMessage to WorkerHandler
+                const eventId = Math.floor(Math.random() * 1000000000);
+                const requestEvent = {
+                    event: {
+                        timestamp: new Date().toISOString(),
+                        eventId,
+                        sender: this.pluginId,
+                        topic: 'global.supabase.requestAccess',
+                        data: {},
+                        debug: false,
+                    },
+                };
                 return new Promise((resolve) => {
-                    this.pendingRequests.push(() => __awaiter(this, void 0, void 0, function* () {
-                        const result = yield this.getClient();
-                        resolve(result);
-                    }));
+                    // Listen for the response
+                    const originalOnMessage = self.onmessage;
+                    self.onmessage = (event) => {
+                        if (event.data?.topic === 'global.supabase.requestAccess' && event.data?.eventId === eventId) {
+                            this.rimoriInfo = event.data.data;
+                            this.supabase = this.getSupabase(this.rimoriInfo.url, this.rimoriInfo.key, this.rimoriInfo.token);
+                            self.onmessage = originalOnMessage; // Restore original handler
+                            resolve({ supabase: this.supabase, info: this.rimoriInfo });
+                        }
+                        else if (originalOnMessage) {
+                            originalOnMessage.call(self, event);
+                        }
+                    };
+                    // Send the request
+                    self.postMessage(requestEvent);
                 });
             }
-            // If we have rimoriInfo from MessageChannel init, use it directly
-            if (this.rimoriInfo && this.supabase) {
-                return { supabase: this.supabase, info: this.rimoriInfo };
-            }
-            // Fallback: request from parent
-            if (!this.rimoriInfo) {
-                if (typeof WorkerGlobalScope !== 'undefined') {
-                    // In worker context, send request via self.postMessage to WorkerHandler
-                    const eventId = Math.floor(Math.random() * 1000000000);
-                    const requestEvent = {
-                        event: {
-                            timestamp: new Date().toISOString(),
-                            eventId,
-                            sender: this.pluginId,
-                            topic: 'global.supabase.requestAccess',
-                            data: {},
-                            debug: false,
-                        },
-                    };
-                    return new Promise((resolve) => {
-                        // Listen for the response
-                        const originalOnMessage = self.onmessage;
-                        self.onmessage = (event) => {
-                            var _a, _b;
-                            if (((_a = event.data) === null || _a === void 0 ? void 0 : _a.topic) === 'global.supabase.requestAccess' && ((_b = event.data) === null || _b === void 0 ? void 0 : _b.eventId) === eventId) {
-                                this.rimoriInfo = event.data.data;
-                                this.supabase = this.getSupabase(this.rimoriInfo.url, this.rimoriInfo.key, this.rimoriInfo.token);
-                                self.onmessage = originalOnMessage; // Restore original handler
-                                resolve({ supabase: this.supabase, info: this.rimoriInfo });
-                            }
-                            else if (originalOnMessage) {
-                                originalOnMessage.call(self, event);
-                            }
-                        };
-                        // Send the request
-                        self.postMessage(requestEvent);
-                    });
-                }
-                else {
-                    // In main thread context, use EventBus
-                    const { data } = yield EventBus.request(this.pluginId, 'global.supabase.requestAccess');
-                    // console.log({ data });
-                    this.rimoriInfo = data;
-                    this.supabase = this.getSupabase(this.rimoriInfo.url, this.rimoriInfo.key, this.rimoriInfo.token);
-                }
+            else {
+                // In main thread context, use EventBus
+                const { data } = await EventBus.request(this.pluginId, 'global.supabase.requestAccess');
+                // console.log({ data });
+                this.rimoriInfo = data;
+                this.supabase = this.getSupabase(this.rimoriInfo.url, this.rimoriInfo.key, this.rimoriInfo.token);
             }
-            return { supabase: this.supabase, info: this.rimoriInfo };
-        });
+        }
+        return { supabase: this.supabase, info: this.rimoriInfo };
     }
     /**
      * Handles updates to RimoriInfo from rimori-main.
@@ -257,7 +244,12 @@ export class RimoriCommunicationHandler {
         if (typeof options.body === 'string') {
             defaultContentType['Content-Type'] = 'application/json';
         }
-        const headers = Object.assign(Object.assign(Object.assign({}, defaultContentType), options.headers), { Authorization: `Bearer ${token}`, 'plugin-id': this.pluginId });
-        return fetch(backendUrl + url, Object.assign(Object.assign({}, options), { headers }));
+        const headers = {
+            ...defaultContentType,
+            ...options.headers,
+            Authorization: `Bearer ${token}`,
+            'plugin-id': this.pluginId,
+        };
+        return fetch(backendUrl + url, { ...options, headers });
     }
 }

package/dist/plugin/Logger.js

@@ -1,22 +1,16 @@
-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());
-    });
-};
 /**
  * Singleton Logger class for Rimori client plugins.
  * Handles all logging levels, production filtering, and log transmission to Rimori.
  * Overrides console methods globally for seamless integration.
  */
 export class Logger {
+    static instance;
+    isProduction;
+    logs = [];
+    logIdCounter = 0;
+    originalConsole;
+    mousePosition = null;
     constructor(rimori, isProduction) {
-        this.logs = [];
-        this.logIdCounter = 0;
-        this.mousePosition = null;
         this.isProduction = this.validateIsProduction(isProduction);
         // Store original console methods
         this.originalConsole = {
@@ -34,8 +28,8 @@ export class Logger {
         this.exposeToDevTools();
         // Set up navigation clearing
         this.setupNavigationClearing();
-        rimori.event.respond('logging.requestPluginLogs', () => __awaiter(this, void 0, void 0, function* () {
-            this.addLogEntry(yield this.createLogEntry('info', 'Screenshot capture', undefined, true));
+        rimori.event.respond('logging.requestPluginLogs', async () => {
+            this.addLogEntry(await this.createLogEntry('info', 'Screenshot capture', undefined, true));
             const logs = {
                 logs: this.logs,
                 pluginId: rimori.plugin.pluginId,
@@ -44,7 +38,7 @@ export class Logger {
             this.logs = [];
             this.logIdCounter = 0;
             return logs;
-        }));
+        });
     }
     /**
      * Initialize the Logger singleton and override console methods globally.
@@ -200,29 +194,27 @@ export class Logger {
      * @param level - Log level
      * @param args - Console arguments
      */
-    handleConsoleCall(level, args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Skip if this is a production log that shouldn't be stored
-            if (this.isProduction && (level === 'debug' || level === 'info')) {
-                return;
+    async handleConsoleCall(level, args) {
+        // Skip if this is a production log that shouldn't be stored
+        if (this.isProduction && (level === 'debug' || level === 'info')) {
+            return;
+        }
+        // Convert console arguments to message and data
+        const message = args
+            .map((arg) => {
+            if (typeof arg !== 'object')
+                return arg;
+            try {
+                return JSON.stringify(arg);
             }
-            // Convert console arguments to message and data
-            const message = args
-                .map((arg) => {
-                if (typeof arg !== 'object')
-                    return arg;
-                try {
-                    return JSON.stringify(arg);
-                }
-                catch (error) {
-                    return 'Error adding object to log: ' + error.message + ' ' + String(arg);
-                }
-            })
-                .join(' ');
-            const data = args.length > 1 ? args.slice(1) : undefined;
-            const entry = yield this.createLogEntry(level, message, data);
-            this.addLogEntry(entry);
-        });
+            catch (error) {
+                return 'Error adding object to log: ' + error.message + ' ' + String(arg);
+            }
+        })
+            .join(' ');
+        const data = args.length > 1 ? args.slice(1) : undefined;
+        const entry = await this.createLogEntry(level, message, data);
+        this.addLogEntry(entry);
     }
     /**
      * Get browser and system information for debugging.
@@ -244,28 +236,26 @@ export class Logger {
      * Dynamically imports html2canvas only in browser environments.
      * @returns Promise resolving to base64 screenshot or null if failed
      */
-    captureScreenshot() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Only attempt to capture screenshot in browser environments
-            if (typeof window === 'undefined' || typeof document === 'undefined') {
-                return null;
-            }
-            try {
-                // Dynamically import html2canvas only when window is available
-                // html2canvas is an optional peer dependency - provided by @rimori/react-client
-                // In worker builds, this import should be marked as external to prevent bundling
-                const html2canvas = (yield import('html2canvas')).default;
-                const canvas = yield html2canvas(document.body);
-                const screenshot = canvas.toDataURL('image/png');
-                // this.originalConsole.log("screenshot captured", screenshot)
-                return screenshot;
-            }
-            catch (error) {
-                // html2canvas may not be available (e.g., in workers or when not installed)
-                // Silently fail to avoid breaking logging functionality
-                return null;
-            }
-        });
+    async captureScreenshot() {
+        // Only attempt to capture screenshot in browser environments
+        if (typeof window === 'undefined' || typeof document === 'undefined') {
+            return null;
+        }
+        try {
+            // Dynamically import html2canvas only when window is available
+            // html2canvas is an optional peer dependency - provided by @rimori/react-client
+            // In worker builds, this import should be marked as external to prevent bundling
+            const html2canvas = (await import('html2canvas')).default;
+            const canvas = await html2canvas(document.body);
+            const screenshot = canvas.toDataURL('image/png');
+            // this.originalConsole.log("screenshot captured", screenshot)
+            return screenshot;
+        }
+        catch (error) {
+            // html2canvas may not be available (e.g., in workers or when not installed)
+            // Silently fail to avoid breaking logging functionality
+            return null;
+        }
     }
     /**
      * Create a log entry with context information.
@@ -274,37 +264,35 @@ export class Logger {
      * @param data - Additional data
      * @returns Log entry
      */
-    createLogEntry(level, message, data, forceScreenshot) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const context = {};
-            // Add URL if available
-            if (typeof window === 'undefined' || typeof document === 'undefined') {
-                return {
-                    id: `log_${++this.logIdCounter}_${Date.now()}`,
-                    timestamp: new Date().toISOString(),
-                    level,
-                    message,
-                    data,
-                };
-            }
-            context.url = window.location.href;
-            // Add browser info (this method now handles worker context internally)
-            context.browserInfo = this.getBrowserInfo();
-            context.userAgent = context.browserInfo.userAgent;
-            // Add screenshot and mouse position if level is error or warn
-            if (level === 'error' || level === 'warn' || forceScreenshot) {
-                context.screenshot = (yield this.captureScreenshot()) || undefined;
-                context.mousePosition = this.mousePosition || undefined;
-            }
+    async createLogEntry(level, message, data, forceScreenshot) {
+        const context = {};
+        // Add URL if available
+        if (typeof window === 'undefined' || typeof document === 'undefined') {
             return {
                 id: `log_${++this.logIdCounter}_${Date.now()}`,
                 timestamp: new Date().toISOString(),
                 level,
                 message,
                 data,
-                context: context,
             };
-        });
+        }
+        context.url = window.location.href;
+        // Add browser info (this method now handles worker context internally)
+        context.browserInfo = this.getBrowserInfo();
+        context.userAgent = context.browserInfo.userAgent;
+        // Add screenshot and mouse position if level is error or warn
+        if (level === 'error' || level === 'warn' || forceScreenshot) {
+            context.screenshot = (await this.captureScreenshot()) || undefined;
+            context.mousePosition = this.mousePosition || undefined;
+        }
+        return {
+            id: `log_${++this.logIdCounter}_${Date.now()}`,
+            timestamp: new Date().toISOString(),
+            level,
+            message,
+            data,
+            context: context,
+        };
     }
     /**
      * Add a log entry to the internal log array.

package/dist/plugin/RimoriClient.js

@@ -1,12 +1,3 @@
-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());
-    });
-};
 import { SharedContentController } from './module/SharedContentController';
 import { RimoriCommunicationHandler } from './CommunicationHandler';
 import { Logger } from './Logger';
@@ -19,17 +10,21 @@ import { StorageModule } from './module/StorageModule';
 import { PostgrestClient } from '@supabase/postgrest-js';
 import { EventBus, EventBusHandler } from '../fromRimori/EventBus';
 export class RimoriClient {
+    static instance;
+    controller;
+    sharedContent;
+    db;
+    event;
+    plugin;
+    ai;
+    exercise;
+    /** Upload and manage images stored in Supabase via the backend. */
+    storage;
+    /** The EventBus instance used by this client. In federation mode this is a per-plugin instance. */
+    eventBus;
     constructor(controller, supabase, info, eventBus) {
-        this.navigation = {
-            toDashboard: () => {
-                this.event.emit('global.navigation.triggerToDashboard');
-            },
-        };
-        this.runtime = {
-            fetchBackend: (url, options = {}) => this.controller.fetchBackend(url, options),
-        };
         this.controller = controller;
-        this.eventBus = eventBus !== null && eventBus !== void 0 ? eventBus : EventBus;
+        this.eventBus = eventBus ?? EventBus;
         this.sharedContent = new SharedContentController(supabase, this);
         this.ai = new AIModule(controller);
         this.ai.setOnRateLimited((exercisesRemaining) => {
@@ -67,22 +62,27 @@ export class RimoriClient {
         // subscribes to triggerUpdate events. PluginEventBridge forwards host-bus events to
         // this plugin's isolated eventBus, so we listen here and hand off to the controller.
         eventBus.on(`${info.pluginId}.supabase.triggerUpdate`, (ev) => {
-            var _a;
-            console.log('[RimoriClient] Federated triggerUpdate received for', info.pluginId, '| ttsEnabled:', (_a = ev.data) === null || _a === void 0 ? void 0 : _a.ttsEnabled);
+            console.log('[RimoriClient] Federated triggerUpdate received for', info.pluginId, '| ttsEnabled:', ev.data?.ttsEnabled);
             controller.handleRimoriInfoUpdate(ev.data);
         });
         return client;
     }
-    static getInstance(pluginId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!RimoriClient.instance) {
-                if (!pluginId)
-                    throw new Error('Plugin ID is required');
-                const controller = new RimoriCommunicationHandler(pluginId, false);
-                const client = yield controller.getClient();
-                RimoriClient.instance = new RimoriClient(controller, client.supabase, client.info);
-            }
-            return RimoriClient.instance;
-        });
+    static async getInstance(pluginId) {
+        if (!RimoriClient.instance) {
+            if (!pluginId)
+                throw new Error('Plugin ID is required');
+            const controller = new RimoriCommunicationHandler(pluginId, false);
+            const client = await controller.getClient();
+            RimoriClient.instance = new RimoriClient(controller, client.supabase, client.info);
+        }
+        return RimoriClient.instance;
     }
+    navigation = {
+        toDashboard: () => {
+            this.event.emit('global.navigation.triggerToDashboard');
+        },
+    };
+    runtime = {
+        fetchBackend: (url, options = {}) => this.controller.fetchBackend(url, options),
+    };
 }