@rimori/client 2.4.0 → 2.5.0-next.1

package/dist/plugin/module/EventModule.d.ts

@@ -0,0 +1,99 @@
+import { MainPanelAction } from '../../fromRimori/PluginTypes';
+import { AccomplishmentPayload } from '../../controller/AccomplishmentController';
+import { EventBusMessage, EventHandler, EventPayload, EventListener } from '../../fromRimori/EventBus';
+/**
+ * Event module for plugin event bus operations.
+ * Provides methods for emitting, listening to, and responding to events.
+ */
+export declare class EventModule {
+    private pluginId;
+    private accomplishmentController;
+    constructor(pluginId: string);
+    getGlobalEventTopic(preliminaryTopic: string): string;
+    /**
+     * Emit an event to Rimori or a plugin.
+     * The topic schema is:
+     * {pluginId}.{eventId}
+     * Check out the event bus documentation for more information.
+     * For triggering events from Rimori like context menu actions use the "global" keyword.
+     * @param topic The topic to emit the event on.
+     * @param data The data to emit.
+     * @param eventId The event id.
+     */
+    emit(topic: string, data?: any, eventId?: number): void;
+    /**
+     * Request an event.
+     * @param topic The topic to request the event on.
+     * @param data The data to request.
+     * @returns The response from the event.
+     */
+    request<T>(topic: string, data?: any): Promise<EventBusMessage<T>>;
+    /**
+     * Subscribe to an event.
+     * @param topic The topic to subscribe to.
+     * @param callback The callback to call when the event is emitted.
+     * @returns An EventListener object containing an off() method to unsubscribe the listeners.
+     */
+    on<T = EventPayload>(topic: string | string[], callback: EventHandler<T>): EventListener;
+    /**
+     * Subscribe to an event once.
+     * @param topic The topic to subscribe to.
+     * @param callback The callback to call when the event is emitted.
+     */
+    once<T = EventPayload>(topic: string, callback: EventHandler<T>): void;
+    /**
+     * Respond to an event.
+     * @param topic The topic to respond to.
+     * @param data The data to respond with.
+     */
+    respond<T = EventPayload>(topic: string | string[], data: EventPayload | ((data: EventBusMessage<T>) => EventPayload | Promise<EventPayload>)): void;
+    /**
+     * Emit an accomplishment.
+     * @param payload The payload to emit.
+     */
+    emitAccomplishment(payload: AccomplishmentPayload): void;
+    /**
+     * Subscribe to an accomplishment.
+     * @param accomplishmentTopic The topic to subscribe to.
+     * @param callback The callback to call when the accomplishment is emitted.
+     */
+    onAccomplishment(accomplishmentTopic: string, callback: (payload: EventBusMessage<AccomplishmentPayload>) => void): void;
+    /**
+     * Trigger an action that opens the sidebar and triggers an action in the designated plugin.
+     * @param pluginId The id of the plugin to trigger the action for.
+     * @param actionKey The key of the action to trigger.
+     * @param text Optional text to be used for the action like for example text that the translator would look up.
+     */
+    emitSidebarAction(pluginId: string, actionKey: string, text?: string): void;
+    /**
+     * Subscribe to main panel actions triggered by the user from the dashboard.
+     * @param callback Handler function that receives the action data when a matching action is triggered.
+     * @param actionsToListen Optional filter to listen only to specific action keys. If empty or not provided, all actions will trigger the callback.
+     * @returns An EventListener object with an `off()` method for cleanup.
+     *
+     * @example
+     * ```ts
+     * const listener = client.event.onMainPanelAction((data) => {
+     *   console.log('Action received:', data.action_key);
+     * }, ['startSession', 'pauseSession']);
+     *
+     * // Clean up when component unmounts to prevent events from firing
+     * // when navigating away or returning to the page
+     * useEffect(() => {
+     *   return () => listener.off();
+     * }, []);
+     * ```
+     *
+     * **Important:** Always call `listener.off()` when your component unmounts or when you no longer need to listen.
+     * This prevents the event handler from firing when navigating away from or returning to the page, which could
+     * cause unexpected behavior or duplicate event handling.
+     */
+    onMainPanelAction(callback: (data: MainPanelAction) => void, actionsToListen?: string | string[]): EventListener;
+    /**
+     * Subscribe to side panel actions triggered by the user from the dashboard.
+     * @param callback Handler function that receives the action data when a matching action is triggered.
+     * @param actionsToListen Optional filter to listen only to specific action keys. If empty or not provided, all actions will trigger the callback.
+     * @returns An EventListener object with an `off()` method for cleanup.
+     */
+    onSidePanelAction(callback: (data: MainPanelAction) => void, actionsToListen?: string | string[]): EventListener;
+}

package/dist/plugin/module/EventModule.js

@@ -0,0 +1,162 @@
+import { AccomplishmentController } from '../../controller/AccomplishmentController';
+import { EventBus } from '../../fromRimori/EventBus';
+/**
+ * Event module for plugin event bus operations.
+ * Provides methods for emitting, listening to, and responding to events.
+ */
+export class EventModule {
+    constructor(pluginId) {
+        this.pluginId = pluginId;
+        this.accomplishmentController = new AccomplishmentController(pluginId);
+    }
+    getGlobalEventTopic(preliminaryTopic) {
+        var _a;
+        if (preliminaryTopic.startsWith('global.')) {
+            return preliminaryTopic;
+        }
+        if (preliminaryTopic.startsWith('self.')) {
+            return preliminaryTopic;
+        }
+        const topicParts = preliminaryTopic.split('.');
+        if (topicParts.length === 3) {
+            if (!topicParts[0].startsWith('pl') && topicParts[0] !== 'global') {
+                throw new Error("The event topic must start with the plugin id or 'global'.");
+            }
+            return preliminaryTopic;
+        }
+        else if (topicParts.length > 3) {
+            throw new Error(`The event topic must consist of 3 parts. <pluginId>.<topic area>.<action>. Received: ${preliminaryTopic}`);
+        }
+        const topicRoot = (_a = this.pluginId) !== null && _a !== void 0 ? _a : 'global';
+        return `${topicRoot}.${preliminaryTopic}`;
+    }
+    /**
+     * Emit an event to Rimori or a plugin.
+     * The topic schema is:
+     * {pluginId}.{eventId}
+     * Check out the event bus documentation for more information.
+     * For triggering events from Rimori like context menu actions use the "global" keyword.
+     * @param topic The topic to emit the event on.
+     * @param data The data to emit.
+     * @param eventId The event id.
+     */
+    emit(topic, data, eventId) {
+        const globalTopic = this.getGlobalEventTopic(topic);
+        EventBus.emit(this.pluginId, globalTopic, data, eventId);
+    }
+    /**
+     * Request an event.
+     * @param topic The topic to request the event on.
+     * @param data The data to request.
+     * @returns The response from the event.
+     */
+    request(topic, data) {
+        const globalTopic = this.getGlobalEventTopic(topic);
+        return EventBus.request(this.pluginId, globalTopic, data);
+    }
+    /**
+     * Subscribe to an event.
+     * @param topic The topic to subscribe to.
+     * @param callback The callback to call when the event is emitted.
+     * @returns An EventListener object containing an off() method to unsubscribe the listeners.
+     */
+    on(topic, callback) {
+        const topics = Array.isArray(topic) ? topic : [topic];
+        return EventBus.on(topics.map((t) => this.getGlobalEventTopic(t)), callback);
+    }
+    /**
+     * Subscribe to an event once.
+     * @param topic The topic to subscribe to.
+     * @param callback The callback to call when the event is emitted.
+     */
+    once(topic, callback) {
+        EventBus.once(this.getGlobalEventTopic(topic), callback);
+    }
+    /**
+     * Respond to an event.
+     * @param topic The topic to respond to.
+     * @param data The data to respond with.
+     */
+    respond(topic, data) {
+        const topics = Array.isArray(topic) ? topic : [topic];
+        EventBus.respond(this.pluginId, topics.map((t) => this.getGlobalEventTopic(t)), data);
+    }
+    /**
+     * Emit an accomplishment.
+     * @param payload The payload to emit.
+     */
+    emitAccomplishment(payload) {
+        this.accomplishmentController.emitAccomplishment(payload);
+    }
+    /**
+     * Subscribe to an accomplishment.
+     * @param accomplishmentTopic The topic to subscribe to.
+     * @param callback The callback to call when the accomplishment is emitted.
+     */
+    onAccomplishment(accomplishmentTopic, callback) {
+        this.accomplishmentController.subscribe(accomplishmentTopic, callback);
+    }
+    /**
+     * Trigger an action that opens the sidebar and triggers an action in the designated plugin.
+     * @param pluginId The id of the plugin to trigger the action for.
+     * @param actionKey The key of the action to trigger.
+     * @param text Optional text to be used for the action like for example text that the translator would look up.
+     */
+    emitSidebarAction(pluginId, actionKey, text) {
+        this.emit('global.sidebar.triggerAction', { plugin_id: pluginId, action_key: actionKey, text });
+    }
+    /**
+     * Subscribe to main panel actions triggered by the user from the dashboard.
+     * @param callback Handler function that receives the action data when a matching action is triggered.
+     * @param actionsToListen Optional filter to listen only to specific action keys. If empty or not provided, all actions will trigger the callback.
+     * @returns An EventListener object with an `off()` method for cleanup.
+     *
+     * @example
+     * ```ts
+     * const listener = client.event.onMainPanelAction((data) => {
+     *   console.log('Action received:', data.action_key);
+     * }, ['startSession', 'pauseSession']);
+     *
+     * // Clean up when component unmounts to prevent events from firing
+     * // when navigating away or returning to the page
+     * useEffect(() => {
+     *   return () => listener.off();
+     * }, []);
+     * ```
+     *
+     * **Important:** Always call `listener.off()` when your component unmounts or when you no longer need to listen.
+     * This prevents the event handler from firing when navigating away from or returning to the page, which could
+     * cause unexpected behavior or duplicate event handling.
+     */
+    onMainPanelAction(callback, actionsToListen = []) {
+        const listeningActions = Array.isArray(actionsToListen) ? actionsToListen : [actionsToListen];
+        // this needs to be a emit and on because the main panel action is triggered by the user and not by the plugin
+        this.emit('action.requestMain');
+        return this.on('action.requestMain', ({ data }) => {
+            // console.log('Received action for main panel ' + data.action_key);
+            // console.log('Listening to actions', listeningActions);
+            if (listeningActions.length === 0 || listeningActions.includes(data.action_key)) {
+                callback(data);
+            }
+        });
+    }
+    /**
+     * Subscribe to side panel actions triggered by the user from the dashboard.
+     * @param callback Handler function that receives the action data when a matching action is triggered.
+     * @param actionsToListen Optional filter to listen only to specific action keys. If empty or not provided, all actions will trigger the callback.
+     * @returns An EventListener object with an `off()` method for cleanup.
+     */
+    onSidePanelAction(callback, actionsToListen = []) {
+        const listeningActions = Array.isArray(actionsToListen) ? actionsToListen : [actionsToListen];
+        // this needs to be a emit and on because the main panel action is triggered by the user and not by the plugin
+        this.emit('action.requestSidebar');
+        return this.on('action.requestSidebar', ({ data }) => {
+            // console.log("eventHandler .onSidePanelAction", data);
+            // console.log('Received action for sidebar ' + data.action);
+            // console.log('Listening to actions', listeningActions);
+            if (listeningActions.length === 0 || listeningActions.includes(data.action)) {
+                callback(data);
+            }
+        });
+    }
+}

package/dist/{controller/ExerciseController.d.ts → plugin/module/ExerciseModule.d.ts}

@@ -1,5 +1,6 @@
-import { SupabaseClient } from '@supabase/supabase-js';
-import { RimoriClient } from '../plugin/RimoriClient';
+import { SupabaseClient } from '../CommunicationHandler';
+import { RimoriCommunicationHandler, RimoriInfo } from '../CommunicationHandler';
+import { EventModule } from './EventModule';
 export type TriggerAction = {
     action_key: string;
 } & Record<string, string | number | boolean>;
@@ -26,33 +27,36 @@ export interface Exercise {
     created_at?: string;
     updated_at?: string;
 }
-export declare class ExerciseController {
+/**
+ * Controller for exercise-related operations.
+ * Provides access to weekly exercises and exercise management.
+ */
+export declare class ExerciseModule {
     private supabase;
-    private rimoriClient;
-    constructor(supabase: SupabaseClient, rimoriClient: RimoriClient);
+    private communicationHandler;
+    private eventModule;
+    private backendUrl;
+    private token;
+    constructor(supabase: SupabaseClient, communicationHandler: RimoriCommunicationHandler, info: RimoriInfo, eventModule: EventModule);
     /**
      * Fetches weekly exercises from the weekly_exercises view.
      * Shows exercises for the current week that haven't expired.
      * @returns Array of exercise objects.
      */
-    viewWeeklyExercises(): Promise<Exercise[]>;
+    view(): Promise<Exercise[]>;
     /**
-     * Creates multiple exercises via the backend API.
-     * All requests are made in parallel but only one event is emitted.
-     * @param token The token to use for authentication.
-     * @param backendUrl The URL of the backend API.
-     * @param exercises Exercise creation parameters.
+     * Creates a new exercise or multiple exercises via the backend API.
+     * When creating multiple exercises, all requests are made in parallel but only one event is emitted.
+     * @param params Exercise creation parameters (single or array).
      * @returns Created exercise objects.
      */
-    addExercise(token: string, backendUrl: string, exercises: CreateExerciseParams[]): Promise<Exercise[]>;
+    add(params: CreateExerciseParams | CreateExerciseParams[]): Promise<Exercise[]>;
     /**
      * Deletes an exercise via the backend API.
-     * @param token The token to use for authentication.
-     * @param backendUrl The URL of the backend API.
-     * @param exerciseId The exercise ID to delete.
+     * @param id The exercise ID to delete.
      * @returns Success status.
      */
-    deleteExercise(token: string, backendUrl: string, id: string): Promise<{
+    delete(id: string): Promise<{
         success: boolean;
         message: string;
     }>;

package/dist/{controller/ExerciseController.js → plugin/module/ExerciseModule.js}

@@ -7,17 +7,27 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-export class ExerciseController {
-    constructor(supabase, rimoriClient) {
+/**
+ * Controller for exercise-related operations.
+ * Provides access to weekly exercises and exercise management.
+ */
+export class ExerciseModule {
+    constructor(supabase, communicationHandler, info, eventModule) {
         this.supabase = supabase;
-        this.rimoriClient = rimoriClient;
+        this.communicationHandler = communicationHandler;
+        this.eventModule = eventModule;
+        this.token = info.token;
+        this.backendUrl = info.backendUrl;
+        this.communicationHandler.onUpdate((updatedInfo) => {
+            this.token = updatedInfo.token;
+        });
     }
     /**
      * Fetches weekly exercises from the weekly_exercises view.
      * Shows exercises for the current week that haven't expired.
      * @returns Array of exercise objects.
      */
-    viewWeeklyExercises() {
+    view() {
         return __awaiter(this, void 0, void 0, function* () {
             const { data, error } = yield this.supabase.from('weekly_exercises').select('*');
             if (error) {
@@ -27,21 +37,20 @@ export class ExerciseController {
         });
     }
     /**
-     * Creates multiple exercises via the backend API.
-     * All requests are made in parallel but only one event is emitted.
-     * @param token The token to use for authentication.
-     * @param backendUrl The URL of the backend API.
-     * @param exercises Exercise creation parameters.
+     * Creates a new exercise or multiple exercises via the backend API.
+     * When creating multiple exercises, all requests are made in parallel but only one event is emitted.
+     * @param params Exercise creation parameters (single or array).
      * @returns Created exercise objects.
      */
-    addExercise(token, backendUrl, exercises) {
+    add(params) {
         return __awaiter(this, void 0, void 0, function* () {
+            const exercises = Array.isArray(params) ? params : [params];
             const responses = yield Promise.all(exercises.map((exercise) => __awaiter(this, void 0, void 0, function* () {
-                const response = yield fetch(`${backendUrl}/exercises`, {
+                const response = yield fetch(`${this.backendUrl}/exercises`, {
                     method: 'POST',
                     headers: {
                         'Content-Type': 'application/json',
-                        Authorization: `Bearer ${token}`,
+                        Authorization: `Bearer ${this.token}`,
                     },
                     body: JSON.stringify(exercise),
                 });
@@ -51,30 +60,28 @@ export class ExerciseController {
                 }
                 return yield response.json();
             })));
-            this.rimoriClient.event.emit('global.exercises.triggerChange');
+            this.eventModule.emit('global.exercises.triggerChange');
             return responses;
         });
     }
     /**
      * Deletes an exercise via the backend API.
-     * @param token The token to use for authentication.
-     * @param backendUrl The URL of the backend API.
-     * @param exerciseId The exercise ID to delete.
+     * @param id The exercise ID to delete.
      * @returns Success status.
      */
-    deleteExercise(token, backendUrl, id) {
+    delete(id) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield fetch(`${backendUrl}/exercises/${id}`, {
+            const response = yield fetch(`${this.backendUrl}/exercises/${id}`, {
                 method: 'DELETE',
                 headers: {
-                    Authorization: `Bearer ${token}`,
+                    Authorization: `Bearer ${this.token}`,
                 },
             });
             if (!response.ok) {
                 const errorText = yield response.text();
                 throw new Error(`Failed to delete exercise: ${errorText}`);
             }
-            this.rimoriClient.event.emit('global.exercises.triggerChange');
+            this.eventModule.emit('global.exercises.triggerChange');
             return yield response.json();
         });
     }

package/dist/plugin/module/PluginModule.d.ts

@@ -0,0 +1,76 @@
+import { UserInfo } from '../../controller/SettingsController';
+import { RimoriCommunicationHandler, RimoriInfo } from '../CommunicationHandler';
+import { Translator } from '../../controller/TranslationController';
+import { ActivePlugin, Plugin } from '../../fromRimori/PluginTypes';
+import { SupabaseClient } from '../CommunicationHandler';
+type Theme = 'light' | 'dark';
+type ApplicationMode = 'main' | 'sidebar' | 'settings';
+/**
+ * Controller for plugin-related operations.
+ * Provides access to plugin settings, user info, and plugin information.
+ */
+export declare class PluginModule {
+    private settingsController;
+    private communicationHandler;
+    private translator;
+    private rimoriInfo;
+    pluginId: string;
+    /**
+     * The release channel of this plugin installation.
+     * Determines which database schema is used for plugin tables.
+     */
+    releaseChannel: string;
+    applicationMode: ApplicationMode;
+    theme: Theme;
+    constructor(supabase: SupabaseClient, communicationHandler: RimoriCommunicationHandler, info: RimoriInfo);
+    /**
+     * Set the settings for the plugin.
+     * @param settings The settings to set.
+     */
+    setSettings(settings: any): Promise<void>;
+    /**
+     * Get the settings for the plugin. T can be any type of settings, UserSettings or SystemSettings.
+     * @param defaultSettings The default settings to use if no settings are found.
+     * @returns The settings for the plugin.
+     */
+    getSettings<T extends object>(defaultSettings: T): Promise<T>;
+    /**
+     * Get the current user info.
+     * Note: For reactive updates in React components, use the userInfo from useRimori() hook instead.
+     * @returns The user info.
+     */
+    getUserInfo(): UserInfo;
+    /**
+     * Register a callback to be notified when RimoriInfo is updated.
+     * This is useful for reacting to changes in user info, tokens, or other rimori data.
+     * @param callback - Function to call with the new RimoriInfo
+     * @returns Cleanup function to unregister the callback
+     */
+    onRimoriInfoUpdate(callback: (info: RimoriInfo) => void): () => void;
+    /**
+     * Retrieves information about plugins, including:
+     * - All installed plugins
+     * - The currently active plugin in the main panel
+     * - The currently active plugin in the side panel
+     */
+    getPluginInfo(): {
+        /**
+         * All installed plugins.
+         */
+        installedPlugins: Plugin[];
+        /**
+         * The plugin that is loaded in the main panel.
+         */
+        mainPanelPlugin?: ActivePlugin;
+        /**
+         * The plugin that is loaded in the side panel.
+         */
+        sidePanelPlugin?: ActivePlugin;
+    };
+    /**
+     * Get the translator for the plugin.
+     * @returns The translator for the plugin.
+     */
+    getTranslator(): Promise<Translator>;
+}
+export {};

package/dist/plugin/module/PluginModule.js

@@ -0,0 +1,88 @@
+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 { SettingsController } from '../../controller/SettingsController';
+import { Translator } from '../../controller/TranslationController';
+/**
+ * Controller for plugin-related operations.
+ * Provides access to plugin settings, user info, and plugin information.
+ */
+export class PluginModule {
+    constructor(supabase, communicationHandler, info) {
+        this.rimoriInfo = info;
+        this.communicationHandler = communicationHandler;
+        this.pluginId = info.pluginId;
+        this.releaseChannel = info.releaseChannel;
+        this.settingsController = new SettingsController(supabase, info.pluginId, info.guild);
+        const currentPlugin = info.installedPlugins.find((plugin) => plugin.id === info.pluginId);
+        this.translator = new Translator(info.interfaceLanguage, (currentPlugin === null || currentPlugin === void 0 ? void 0 : currentPlugin.endpoint) || '');
+        this.communicationHandler.onUpdate((updatedInfo) => (this.rimoriInfo = updatedInfo));
+        this.applicationMode = this.communicationHandler.getQueryParam('applicationMode');
+        this.theme = this.communicationHandler.getQueryParam('rm_theme') || 'light';
+    }
+    /**
+     * Set the settings for the plugin.
+     * @param settings The settings to set.
+     */
+    setSettings(settings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.settingsController.setSettings(settings);
+        });
+    }
+    /**
+     * Get the settings for the plugin. T can be any type of settings, UserSettings or SystemSettings.
+     * @param defaultSettings The default settings to use if no settings are found.
+     * @returns The settings for the plugin.
+     */
+    getSettings(defaultSettings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.settingsController.getSettings(defaultSettings);
+        });
+    }
+    /**
+     * Get the current user info.
+     * Note: For reactive updates in React components, use the userInfo from useRimori() hook instead.
+     * @returns The user info.
+     */
+    getUserInfo() {
+        return this.rimoriInfo.profile;
+    }
+    /**
+     * Register a callback to be notified when RimoriInfo is updated.
+     * This is useful for reacting to changes in user info, tokens, or other rimori data.
+     * @param callback - Function to call with the new RimoriInfo
+     * @returns Cleanup function to unregister the callback
+     */
+    onRimoriInfoUpdate(callback) {
+        return this.communicationHandler.onUpdate(callback);
+    }
+    /**
+     * Retrieves information about plugins, including:
+     * - All installed plugins
+     * - The currently active plugin in the main panel
+     * - The currently active plugin in the side panel
+     */
+    getPluginInfo() {
+        return {
+            installedPlugins: this.rimoriInfo.installedPlugins,
+            mainPanelPlugin: this.rimoriInfo.mainPanelPlugin,
+            sidePanelPlugin: this.rimoriInfo.sidePanelPlugin,
+        };
+    }
+    /**
+     * Get the translator for the plugin.
+     * @returns The translator for the plugin.
+     */
+    getTranslator() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.translator.initialize();
+            return this.translator;
+        });
+    }
+}

package/package.json

@@ -1,18 +1,22 @@
 {
   "name": "@rimori/client",
-  "version": "2.4.0",
+  "version": "2.5.0-next.1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": {
     "type": "git",
     "url": "https://github.com/rimori-org/rimori-client.git"
   },
-  "license": "apache-2.0",
+  "license": "Apache-2.0",
   "bin": {
     "rimori-release": "./dist/cli/scripts/release/release.js",
     "rimori-init": "./dist/cli/scripts/init/main.js"
   },
   "type": "module",
+  "files": [
+    "dist",
+    "README.md"
+  ],
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -27,12 +31,13 @@
     "format": "prettier --write ."
   },
   "dependencies": {
-    "@supabase/supabase-js": "2.49.4",
+    "@supabase/postgrest-js": "^2.87.1",
     "dotenv": "16.5.0",
     "i18next": "^25.6.0"
   },
   "devDependencies": {
     "@eslint/js": "^9.37.0",
+    "@types/node": "^25.0.1",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-prettier": "^5.5.4",
     "eslint-plugin-react-hooks": "^7.0.0",