@rimori/client 1.0.5 → 1.1.1

package/dist/controller/SharedContentController.d.ts

@@ -1,22 +1,69 @@
-import { ObjectRequest } from "./ObjectController";
+import { SupabaseClient } from '@supabase/supabase-js';
 import { RimoriClient } from "../plugin/RimoriClient";
-export interface BasicAssignment {
+import { ObjectRequest } from "./ObjectController";
+export interface BasicAssignment<T> {
     id: string;
     createdAt: Date;
     topic: string;
     createdBy: string;
     verified: boolean;
     keywords: any;
+    data: T;
+}
+export interface SharedContentObjectRequest extends ObjectRequest {
+    fixedProperties?: Record<string, string | number | boolean>;
 }
+export type SharedContentFilter = Record<string, string | number | boolean>;
 export declare class SharedContentController {
+    private supabase;
     private rimoriClient;
-    constructor(rimoriClient: RimoriClient);
-    fetchNewSharedContent<T, R = T & BasicAssignment>(type: string, generatorInstructions: (reservedTopics: string[]) => Promise<ObjectRequest> | ObjectRequest, filter?: {
-        column: string;
-        value: string | number | boolean;
-    }): Promise<R[]>;
-    private getReservedTopics;
-    private purifyStringArray;
-    getSharedContent<T extends BasicAssignment>(type: string, id: string): Promise<T>;
-    completeSharedContent(type: string, assignmentId: string): Promise<void>;
+    constructor(supabase: SupabaseClient, rimoriClient: RimoriClient);
+    /**
+     * Fetch new shared content for a given content type.
+     * @param contentType - The type of content to fetch.
+     * @param generatorInstructions - The instructions for the generator. The object needs to have a tool property with a topic and keywords property to let a new unique topic be generated.
+     * @param filter - An optional filter to apply to the query.
+     * @param privateTopic - An optional flag to indicate if the topic should be private and only be visible to the user.
+     * @returns The new shared content.
+     */
+    getNewSharedContent<T>(contentType: string, generatorInstructions: SharedContentObjectRequest, filter?: SharedContentFilter, privateTopic?: boolean): Promise<BasicAssignment<T>>;
+    private getGeneratorInstructions;
+    private getCompletedTopics;
+    getSharedContent<T>(contentType: string, id: string): Promise<BasicAssignment<T>>;
+    completeSharedContent(contentType: string, assignmentId: string): Promise<void>;
+    /**
+     * Fetch shared content from the database based on optional filters.
+     * @param contentType - The type of content to fetch.
+     * @param filter - Optional filter to apply to the query.
+     * @param limit - Optional limit for the number of results.
+     * @returns Array of shared content matching the criteria.
+     */
+    getSharedContentList<T>(contentType: string, filter?: SharedContentFilter, limit?: number): Promise<BasicAssignment<T>[]>;
+    /**
+     * Insert new shared content into the database.
+     * @param param
+     * @param param.contentType - The type of content to insert.
+     * @param param.topic - The topic of the content.
+     * @param param.keywords - Keywords associated with the content.
+     * @param param.data - The content data to store.
+     * @param param.privateTopic - Optional flag to indicate if the topic should be private.
+     * @returns The inserted shared content.
+     * @throws {Error} if insertion fails.
+     */
+    createSharedContent<T>({ contentType, topic, keywords, data, privateTopic }: SharedContent<T>): Promise<BasicAssignment<T>>;
+    /**
+     * Update existing shared content in the database.
+     * @param id - The ID of the content to update.
+     * @param updates - The updates to apply to the shared content.
+     * @returns The updated shared content.
+     * @throws {Error} if update fails.
+     */
+    updateSharedContent<T>(id: string, updates: Partial<SharedContent<T>>): Promise<BasicAssignment<T>>;
+}
+export interface SharedContent<T> {
+    contentType: string;
+    topic: string;
+    keywords: string[];
+    data: T;
+    privateTopic?: boolean;
 }

package/dist/controller/SharedContentController.js

@@ -7,50 +7,185 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { v4 as uuidv4 } from 'uuid';
 export class SharedContentController {
-    constructor(rimoriClient) {
+    constructor(supabase, rimoriClient) {
+        this.supabase = supabase;
         this.rimoriClient = rimoriClient;
     }
-    fetchNewSharedContent(type, generatorInstructions, filter) {
+    /**
+     * Fetch new shared content for a given content type.
+     * @param contentType - The type of content to fetch.
+     * @param generatorInstructions - The instructions for the generator. The object needs to have a tool property with a topic and keywords property to let a new unique topic be generated.
+     * @param filter - An optional filter to apply to the query.
+     * @param privateTopic - An optional flag to indicate if the topic should be private and only be visible to the user.
+     * @returns The new shared content.
+     */
+    getNewSharedContent(contentType, generatorInstructions, 
+    //this filter is there if the content should be filtered additionally by a column and value
+    filter, privateTopic) {
         return __awaiter(this, void 0, void 0, function* () {
-            const queryParameter = { filter_column: (filter === null || filter === void 0 ? void 0 : filter.column) || null, filter_value: (filter === null || filter === void 0 ? void 0 : filter.value) || null, unread: true };
-            const { data: newAssignments } = yield this.rimoriClient.db.rpc(type + "_entries", queryParameter);
+            const query = this.supabase.from("shared_content")
+                .select("*, scc:shared_content_completed(id)")
+                .eq('content_type', contentType)
+                .is('scc.id', null)
+                .limit(10);
+            if (filter) {
+                query.contains('data', filter);
+            }
+            const { data: newAssignments, error } = yield query;
+            if (error) {
+                console.error('error fetching new assignments:', error);
+                throw new Error('error fetching new assignments');
+            }
             console.log('newAssignments:', newAssignments);
             if (newAssignments.length > 0) {
-                return newAssignments;
+                const index = Math.floor(Math.random() * newAssignments.length);
+                return newAssignments[index];
             }
             // generate new assignments
-            const { data: oldAssignments } = yield this.rimoriClient.db.rpc(type + "_entries", Object.assign(Object.assign({}, queryParameter), { unread: false }));
-            console.log('oldAssignments:', oldAssignments);
-            const reservedTopics = this.getReservedTopics(oldAssignments);
-            const request = yield generatorInstructions(reservedTopics);
-            if (!request.tool.keywords || !request.tool.topic) {
-                throw new Error("topic or keywords not found in the request schema");
-            }
-            const instructions = yield this.rimoriClient.llm.getObject(request);
+            const fullInstructions = yield this.getGeneratorInstructions(contentType, generatorInstructions, filter);
+            console.log('fullInstructions:', fullInstructions);
+            const instructions = yield this.rimoriClient.llm.getObject(fullInstructions);
             console.log('instructions:', instructions);
-            const preparedData = Object.assign(Object.assign({ id: uuidv4() }, instructions), { keywords: this.purifyStringArray(instructions.keywords) });
-            return yield this.rimoriClient.db.from(type).insert(preparedData).then(() => [preparedData]);
+            const { data: newAssignment, error: insertError } = yield this.supabase.from("shared_content").insert({
+                private: privateTopic,
+                content_type: contentType,
+                topic: instructions.topic,
+                keywords: instructions.keywords.map(({ text }) => text),
+                data: Object.assign(Object.assign(Object.assign({}, instructions), { topic: undefined, keywords: undefined }), generatorInstructions.fixedProperties),
+            }).select();
+            if (insertError) {
+                console.error('error inserting new assignment:', insertError);
+                throw new Error('error inserting new assignment');
+            }
+            return newAssignment[0];
+        });
+    }
+    getGeneratorInstructions(contentType, generatorInstructions, filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const completedTopics = yield this.getCompletedTopics(contentType, filter);
+            generatorInstructions.instructions += `
+    The following topics are already taken: ${completedTopics.join(', ')}`;
+            generatorInstructions.tool.topic = {
+                type: "string",
+                description: "What the topic is about. Short. ",
+            };
+            generatorInstructions.tool.keywords = {
+                type: [{ text: { type: "string" } }],
+                description: "Keywords around the topic of the assignment.",
+            };
+            return generatorInstructions;
+        });
+    }
+    getCompletedTopics(contentType, filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = this.supabase.from("shared_content")
+                .select("topic, keywords, scc:shared_content_completed(id)")
+                .eq('content_type', contentType)
+                .not('scc.id', 'is', null);
+            if (filter) {
+                query.contains('data', filter);
+            }
+            const { data: oldAssignments, error } = yield query;
+            if (error) {
+                console.error('error fetching old assignments:', error);
+                return [];
+            }
+            return oldAssignments.map(({ topic, keywords }) => `${topic}(${keywords.join(',')})`);
         });
     }
-    getReservedTopics(oldAssignments) {
-        return oldAssignments.map(({ topic, keywords }) => {
-            const keywordTexts = this.purifyStringArray(keywords).join(',');
-            return `${topic}(${keywordTexts})`;
+    getSharedContent(contentType, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data, error } = yield this.supabase.from("shared_content").select().eq('content_type', contentType).eq('id', id).single();
+            if (error) {
+                console.error('error fetching shared content:', error);
+                throw new Error('error fetching shared content');
+            }
+            return data;
         });
     }
-    purifyStringArray(array) {
-        return array.map(({ text }) => text);
+    completeSharedContent(contentType, assignmentId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.supabase.from("shared_content_completed").insert({ content_type: contentType, id: assignmentId });
+        });
     }
-    getSharedContent(type, id) {
+    /**
+     * Fetch shared content from the database based on optional filters.
+     * @param contentType - The type of content to fetch.
+     * @param filter - Optional filter to apply to the query.
+     * @param limit - Optional limit for the number of results.
+     * @returns Array of shared content matching the criteria.
+     */
+    getSharedContentList(contentType, filter, limit) {
         return __awaiter(this, void 0, void 0, function* () {
-            return yield this.rimoriClient.db.from(type).select().eq('id', id).single();
+            const query = this.supabase.from("shared_content").select("*").eq('content_type', contentType).limit(limit !== null && limit !== void 0 ? limit : 30);
+            if (filter) {
+                query.contains('data', filter);
+            }
+            const { data, error } = yield query;
+            if (error) {
+                console.error('error fetching shared content:', error);
+                throw new Error('error fetching shared content');
+            }
+            return data;
         });
     }
-    completeSharedContent(type, assignmentId) {
+    /**
+     * Insert new shared content into the database.
+     * @param param
+     * @param param.contentType - The type of content to insert.
+     * @param param.topic - The topic of the content.
+     * @param param.keywords - Keywords associated with the content.
+     * @param param.data - The content data to store.
+     * @param param.privateTopic - Optional flag to indicate if the topic should be private.
+     * @returns The inserted shared content.
+     * @throws {Error} if insertion fails.
+     */
+    createSharedContent(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ contentType, topic, keywords, data, privateTopic }) {
+            const { data: newContent, error } = yield this.supabase.from("shared_content").insert({
+                private: privateTopic,
+                content_type: contentType,
+                topic,
+                keywords,
+                data,
+            }).select();
+            if (error) {
+                console.error('error inserting shared content:', error);
+                throw new Error('error inserting shared content');
+            }
+            return newContent[0];
+        });
+    }
+    /**
+     * Update existing shared content in the database.
+     * @param id - The ID of the content to update.
+     * @param updates - The updates to apply to the shared content.
+     * @returns The updated shared content.
+     * @throws {Error} if update fails.
+     */
+    updateSharedContent(id, updates) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.rimoriClient.db.from(type + "_result").insert({ assignment_id: assignmentId });
+            const updateData = {};
+            if (updates.contentType)
+                updateData.content_type = updates.contentType;
+            if (updates.topic)
+                updateData.topic = updates.topic;
+            if (updates.keywords)
+                updateData.keywords = updates.keywords;
+            if (updates.data)
+                updateData.data = updates.data;
+            if (updates.privateTopic !== undefined)
+                updateData.private = updates.privateTopic;
+            const { data: updatedContent, error } = yield this.supabase.from("shared_content").update(updateData).eq('id', id).select();
+            if (error) {
+                console.error('error updating shared content:', error);
+                throw new Error('error updating shared content');
+            }
+            if (!updatedContent || updatedContent.length === 0) {
+                throw new Error('shared content not found');
+            }
+            return updatedContent[0];
         });
     }
 }

package/dist/controller/SidePluginController.d.ts

@@ -1,14 +1,3 @@
 import { SupabaseClient } from '@supabase/supabase-js';
-export interface Plugin {
-    id: string;
-    title: string;
-    icon_url: string;
-    website: string;
-    context_menu_actions: string;
-    plugin_pages: string;
-    sidebar_pages: string;
-    settings_page: string;
-    version: string;
-    external_hosted_url: string;
-}
+import { Plugin } from '../plugin/fromRimori/PluginTypes';
 export declare function getPlugins(supabase: SupabaseClient): Promise<Plugin[]>;

package/dist/controller/SidePluginController.js

@@ -17,8 +17,9 @@ export function getPlugins(supabase) {
         return (data || []).map((plugin) => ({
             id: plugin.id,
             title: plugin.title,
+            description: plugin.description,
             icon_url: plugin.icon_url,
-            website: plugin.website,
+            endpoint: plugin.endpoint,
             context_menu_actions: plugin.context_menu_actions,
             plugin_pages: plugin.plugin_pages,
             sidebar_pages: plugin.sidebar_pages,

package/dist/core/components/ContextMenu.d.ts

@@ -0,0 +1,10 @@
+import { RimoriClient } from "../../plugin/RimoriClient";
+export interface Position {
+    x: number;
+    y: number;
+    text?: string;
+}
+declare const ContextMenu: ({ client }: {
+    client: RimoriClient;
+}) => import("react/jsx-runtime").JSX.Element | null;
+export default ContextMenu;

package/dist/core/components/ContextMenu.js

@@ -0,0 +1,93 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect, useRef } from "react";
+import { EventBus } from "../../plugin/fromRimori/EventBus";
+const ContextMenu = ({ client }) => {
+    const [isOpen, setIsOpen] = useState(false);
+    const [actions, setActions] = useState([]);
+    const [position, setPosition] = useState({ x: 0, y: 0 });
+    const [openOnTextSelect, setOpenOnTextSelect] = useState(false);
+    const menuRef = useRef(null);
+    useEffect(() => {
+        client.plugin.getInstalled().then(plugins => {
+            setActions(plugins.flatMap(p => p.context_menu_actions).filter(Boolean));
+        });
+        client.plugin.getUserInfo().then((userInfo) => {
+            setOpenOnTextSelect(userInfo.context_menu_on_select);
+        });
+        EventBus.on("global.contextMenu.createActions", ({ data }) => {
+            setActions([...data.actions, ...actions]);
+        });
+    }, []);
+    useEffect(() => {
+        // Track mouse position globally
+        const handleMouseMove = (e) => {
+            var _a;
+            const selectedText = (_a = window.getSelection()) === null || _a === void 0 ? void 0 : _a.toString().trim();
+            if (isOpen && selectedText === position.text)
+                return;
+            setPosition({ x: e.clientX, y: e.clientY, text: selectedText });
+        };
+        const handleMouseUp = (e) => {
+            var _a, _b;
+            const selectedText = (_a = window.getSelection()) === null || _a === void 0 ? void 0 : _a.toString().trim();
+            // Check if click is inside the context menu
+            if (menuRef.current && menuRef.current.contains(e.target)) {
+                // Don't close the menu if clicking inside
+                return;
+            }
+            // Prevent context menu on textarea or text input selection
+            const target = e.target;
+            const isTextInput = target && ((target.tagName === 'TEXTAREA') ||
+                (target.tagName === 'INPUT' && target.type === 'text'));
+            if (isTextInput) {
+                setIsOpen(false);
+                return;
+            }
+            if (e.button === 0 && isOpen) {
+                setIsOpen(false);
+                (_b = window.getSelection()) === null || _b === void 0 ? void 0 : _b.removeAllRanges();
+            }
+            else if (selectedText && (openOnTextSelect || e.button === 2)) {
+                if (e.button === 2) {
+                    e.preventDefault();
+                }
+                setPosition({ x: e.clientX, y: e.clientY, text: selectedText });
+                setIsOpen(true);
+            }
+            else {
+                setIsOpen(false);
+            }
+        };
+        // Add selectionchange listener to close menu if selection is cleared
+        const handleSelectionChange = () => {
+            var _a;
+            const selectedText = (_a = window.getSelection()) === null || _a === void 0 ? void 0 : _a.toString().trim();
+            if (!selectedText && isOpen) {
+                setIsOpen(false);
+            }
+        };
+        document.addEventListener("mouseup", handleMouseUp);
+        window.addEventListener("mousemove", handleMouseMove);
+        document.addEventListener("contextmenu", handleMouseUp);
+        document.addEventListener("selectionchange", handleSelectionChange);
+        return () => {
+            document.removeEventListener("mouseup", handleMouseUp);
+            window.removeEventListener("mousemove", handleMouseMove);
+            document.removeEventListener("contextmenu", handleMouseUp);
+            document.removeEventListener("selectionchange", handleSelectionChange);
+        };
+    }, [openOnTextSelect, isOpen, position.text]);
+    if (!isOpen) {
+        return null;
+    }
+    return (_jsx("div", { ref: menuRef, className: "fixed bg-gray-400 dark:bg-gray-700 shadow-lg border border-gray-400 rounded-md overflow-hidden dark:text-white z-50", style: { top: position.y, left: position.x }, children: actions.map((action, index) => (_jsx(MenuEntryItem, { icon: action.icon, text: action.text, onClick: () => {
+                var _a;
+                setIsOpen(false);
+                (_a = window.getSelection()) === null || _a === void 0 ? void 0 : _a.removeAllRanges();
+                client.event.emitSidebarAction(action.pluginId, action.actionKey, position.text);
+            } }, index))) }));
+};
+function MenuEntryItem(props) {
+    return _jsxs("button", { onClick: props.onClick, className: "px-4 py-2 text-left hover:bg-gray-500 dark:hover:bg-gray-600 w-full flex flex-row", children: [_jsx("span", { className: "flex-grow", children: props.icon }), _jsx("span", { className: "flex-grow", children: props.text })] });
+}
+export default ContextMenu;

package/dist/core.d.ts

@@ -1,9 +1,6 @@
-export * from "./controller/AIController";
-export * from "./controller/SharedContentController";
-export * from "./controller/SettingsController";
 export * from "./plugin/RimoriClient";
 export * from "./plugin/PluginController";
 export * from "./utils/difficultyConverter";
 export * from "./utils/PluginUtils";
 export * from "./worker/WorkerSetup";
-export * from "./plugin/fromRimori/EventBus";
+export * from "./utils/Language";

package/dist/core.js

@@ -1,10 +1,7 @@
 // Core functionality exports
-export * from "./controller/AIController";
-export * from "./controller/SharedContentController";
-export * from "./controller/SettingsController";
 export * from "./plugin/RimoriClient";
 export * from "./plugin/PluginController";
 export * from "./utils/difficultyConverter";
 export * from "./utils/PluginUtils";
 export * from "./worker/WorkerSetup";
-export * from "./plugin/fromRimori/EventBus";
+export * from "./utils/Language";

package/dist/hooks/UseChatHook.d.ts

@@ -1,5 +1,5 @@
 import React from "react";
-import { Tool, Message } from "../controller/AIController";
+import { Message, Tool } from "../controller/AIController";
 export declare function useChat(tools?: Tool[]): {
     messages: Message[];
     append: (appendMessages: Message[]) => void;

package/dist/index.d.ts

@@ -1,15 +1,7 @@
 export * from './core';
 export * from './components';
-export * from "./components/MarkdownEditor";
-export * from "./components/CRUDModal";
-export * from "./components/Spinner";
-export * from "./components/audio/Playbutton";
-export * from "./controller/AIController";
-export * from "./controller/SharedContentController";
-export * from "./controller/SettingsController";
 export * from "./hooks/UseChatHook";
 export * from "./plugin/RimoriClient";
-export * from "./plugin/ThemeSetter";
 export * from "./providers/PluginProvider";
 export * from "./utils/difficultyConverter";
 export * from "./utils/PluginUtils";

package/dist/index.js

@@ -1,16 +1,8 @@
 // Re-export everything
 export * from './core';
 export * from './components';
-export * from "./components/MarkdownEditor";
-export * from "./components/CRUDModal";
-export * from "./components/Spinner";
-export * from "./components/audio/Playbutton";
-export * from "./controller/AIController";
-export * from "./controller/SharedContentController";
-export * from "./controller/SettingsController";
 export * from "./hooks/UseChatHook";
 export * from "./plugin/RimoriClient";
-export * from "./plugin/ThemeSetter";
 export * from "./providers/PluginProvider";
 export * from "./utils/difficultyConverter";
 export * from "./utils/PluginUtils";

package/dist/plugin/AccomplishmentHandler.d.ts

@@ -0,0 +1,38 @@
+import { EventBusMessage } from "./fromRimori/EventBus";
+export type AccomplishmentMessage = EventBusMessage<MicroAccomplishmentPayload>;
+export declare const skillCategories: readonly ["reading", "listening", "speaking", "writing", "learning", "community"];
+interface BaseAccomplishmentPayload {
+    type: "micro" | "macro";
+    skillCategory: (typeof skillCategories)[number];
+    accomplishmentKeyword: string;
+    description: string;
+    meta?: {
+        key: string;
+        value: string | number | boolean;
+        description: string;
+    }[];
+}
+export interface MicroAccomplishmentPayload extends BaseAccomplishmentPayload {
+    type: "micro";
+}
+export interface MacroAccomplishmentPayload extends BaseAccomplishmentPayload {
+    type: "macro";
+    errorRatio: number;
+    durationMinutes: number;
+}
+export type AccomplishmentPayload = MicroAccomplishmentPayload | MacroAccomplishmentPayload;
+export declare class AccomplishmentHandler {
+    private pluginId;
+    constructor(pluginId: string);
+    emitAccomplishment(payload: Omit<AccomplishmentPayload, "type">): void;
+    private validateAccomplishment;
+    private sanitizeAccomplishment;
+    private getDecoupledTopic;
+    /**
+     * Subscribe to accomplishment events
+     * @param accomplishmentTopic - The topic of the accomplishment event. The pattern can be any pattern of plugin.skillCategory.accomplishmentKeyword or an * as wildcard for any plugin, skill category or accomplishment keyword
+     * @param callback - The callback function to be called when the accomplishment event is triggered
+     */
+    subscribe(accomplishmentTopics: string | string[] | undefined, callback: (payload: EventBusMessage<AccomplishmentPayload>) => void): void;
+}
+export {};

package/dist/plugin/AccomplishmentHandler.js

@@ -0,0 +1,108 @@
+import { EventBus } from "./fromRimori/EventBus";
+export const skillCategories = ["reading", "listening", "speaking", "writing", "learning", "community"];
+export class AccomplishmentHandler {
+    constructor(pluginId) {
+        this.pluginId = pluginId;
+    }
+    emitAccomplishment(payload) {
+        const accomplishmentPayload = Object.assign(Object.assign({}, payload), { type: "durationMinutes" in payload ? "macro" : "micro" });
+        this.validateAccomplishment(accomplishmentPayload);
+        const sanitizedPayload = this.sanitizeAccomplishment(accomplishmentPayload);
+        const topic = "global.accomplishment.trigger" + (accomplishmentPayload.type === "macro" ? "Macro" : "Micro");
+        EventBus.emit(this.pluginId, topic, sanitizedPayload);
+    }
+    validateAccomplishment(payload) {
+        if (!skillCategories.includes(payload.skillCategory)) {
+            throw new Error(`Invalid skill category: ${payload.skillCategory}`);
+        }
+        //regex validate accomplishmentKeyword
+        if (!/^[a-z_-]+$/.test(payload.accomplishmentKeyword)) {
+            throw new Error(`The accomplishment keyword: ${payload.accomplishmentKeyword} is invalid. Only lowercase letters, minuses and underscores are allowed`);
+        }
+        //description is required
+        if (payload.description.length < 10) {
+            throw new Error("Description is too short");
+        }
+        //check that the type is valid
+        if (!["micro", "macro"].includes(payload.type)) {
+            throw new Error("Invalid accomplishment type " + payload.type);
+        }
+        //durationMinutes is required
+        if (payload.type === "macro" && payload.durationMinutes < 4) {
+            throw new Error("The duration must be at least 4 minutes");
+        }
+        //errorRatio is required
+        if (payload.type === "macro" && (payload.errorRatio < 0 || payload.errorRatio > 1)) {
+            throw new Error("The error ratio must be between 0 and 1");
+        }
+        //regex check meta data key
+        if (payload.meta) {
+            payload.meta.forEach(meta => {
+                if (!/^[a-z_]+$/.test(meta.key)) {
+                    throw new Error("Invalid meta data key " + meta.key + ", only lowercase letters and underscores are allowed");
+                }
+            });
+        }
+    }
+    sanitizeAccomplishment(payload) {
+        var _a;
+        payload.description = payload.description.replace(/[^\x20-\x7E]/g, "");
+        (_a = payload.meta) === null || _a === void 0 ? void 0 : _a.forEach((meta) => {
+            meta.description = meta.description.replace(/[^\x20-\x7E]/g, "");
+        });
+        return payload;
+    }
+    getDecoupledTopic(topic) {
+        const [plugin, skillCategory, accomplishmentKeyword] = topic.split(".");
+        return { plugin: plugin || "*", skillCategory: skillCategory || "*", accomplishmentKeyword: accomplishmentKeyword || "*" };
+    }
+    /**
+     * Subscribe to accomplishment events
+     * @param accomplishmentTopic - The topic of the accomplishment event. The pattern can be any pattern of plugin.skillCategory.accomplishmentKeyword or an * as wildcard for any plugin, skill category or accomplishment keyword
+     * @param callback - The callback function to be called when the accomplishment event is triggered
+     */
+    subscribe(accomplishmentTopics = "*", callback) {
+        if (typeof accomplishmentTopics === "string") {
+            accomplishmentTopics = [accomplishmentTopics];
+        }
+        accomplishmentTopics.forEach((accomplishmentTopic) => {
+            const topicLength = accomplishmentTopic.split(".").length;
+            if (topicLength === 1) {
+                accomplishmentTopic += ".*.*";
+            }
+            else if (topicLength === 2) {
+                accomplishmentTopic += ".*";
+            }
+            else if (topicLength !== 3) {
+                throw new Error("Invalid accomplishment topic pattern. The pattern must be plugin.skillCategory.accomplishmentKeyword or an * as wildcard for any plugin, skill category or accomplishment keyword");
+            }
+            EventBus.on(["global.accomplishment.triggerMicro", "global.accomplishment.triggerMacro"], (event) => {
+                const { plugin, skillCategory, accomplishmentKeyword } = this.getDecoupledTopic(accomplishmentTopic);
+                if (plugin !== "*" && event.sender !== plugin)
+                    return;
+                if (skillCategory !== "*" && event.data.skillCategory !== skillCategory)
+                    return;
+                if (accomplishmentKeyword !== "*" && event.data.accomplishmentKeyword !== accomplishmentKeyword)
+                    return;
+                callback(event);
+            }, [this.pluginId]);
+        });
+    }
+}
+// const accomplishmentHandler = AccomplishmentHandler.getInstance("my-plugin");
+// accomplishmentHandler.subscribe("*", (payload) => {
+//   console.log(payload);
+// });
+// accomplishmentHandler.emitAccomplishment({
+//   skillCategory: "reading",
+//   accomplishmentKeyword: "chapter",
+//   description: "Read chapter 1 of the book",
+//   durationMinutes: 10,
+//   meta: [
+//     {
+//       key: "book",
+//       value: "The Great Gatsby",
+//       description: "The book I read",
+//     },
+//   ],
+// });