@rimori/client 1.0.0

package/dist/providers/PluginProvider.js

@@ -0,0 +1,52 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useEffect, useState } from 'react';
+import { PluginController } from '../plugin/PluginController';
+const PluginContext = createContext(null);
+export const PluginProvider = ({ children }) => {
+    const [plugin, setPlugin] = useState(null);
+    //route change
+    useEffect(() => {
+        let lastHash = window.location.hash;
+        setInterval(() => {
+            if (lastHash !== window.location.hash) {
+                lastHash = window.location.hash;
+                console.log('url changed:', lastHash);
+                plugin === null || plugin === void 0 ? void 0 : plugin.emit('urlChange', window.location.hash);
+            }
+        }, 100);
+        PluginController.getInstance().then(setPlugin);
+    }, []);
+    //context menu
+    useEffect(() => {
+        let isOpen = false;
+        const handleContextMenu = (e) => {
+            var _a;
+            const selection = (_a = window.getSelection()) === null || _a === void 0 ? void 0 : _a.toString().trim();
+            if (selection) {
+                e.preventDefault();
+                // console.log('context menu', selection);
+                plugin === null || plugin === void 0 ? void 0 : plugin.emit('contextMenu', { text: selection, x: e.clientX, y: e.clientY, open: true });
+                isOpen = true;
+            }
+        };
+        // Hide the menu on click outside
+        const handleClick = () => isOpen && (plugin === null || plugin === void 0 ? void 0 : plugin.emit('contextMenu', { text: '', x: 0, y: 0, open: false }));
+        document.addEventListener("click", handleClick);
+        document.addEventListener('contextmenu', handleContextMenu);
+        return () => {
+            document.removeEventListener("click", handleClick);
+            document.removeEventListener('contextmenu', handleContextMenu);
+        };
+    }, [plugin]);
+    if (!plugin) {
+        return "";
+    }
+    return (_jsx(PluginContext.Provider, { value: plugin, children: children }));
+};
+export const usePlugin = () => {
+    const context = useContext(PluginContext);
+    if (context === null) {
+        throw new Error('usePlugin must be used within an PluginProvider');
+    }
+    return context;
+};

package/dist/style.css

@@ -0,0 +1,110 @@
+dialog::backdrop {
+  backdrop-filter: blur(2px);
+}
+
+.dark * dialog::backdrop {
+  background: transparent;
+}
+
+.tiptap {
+  padding-top: 5px;
+  padding-left: 7px;
+  /* min-height: 300px; */
+}
+.tiptap:focus-visible {
+  outline: none;
+}
+.tiptap h1,
+.tiptap h2,
+.tiptap h3,
+.tiptap h4,
+.tiptap h5,
+.tiptap h6 {
+  @apply font-bold;
+  margin-bottom: 1rem;
+}
+.tiptap h1 {
+  @apply text-4xl;
+}
+.tiptap h2 {
+  @apply text-3xl;
+}
+.tiptap h3 {
+  @apply text-2xl;
+}
+.tiptap h4 {
+  @apply text-xl;
+}
+.tiptap h5 {
+  @apply text-lg;
+}
+.tiptap h6 {
+  @apply text-base;
+}
+.tiptap p {
+  @apply mb-4;
+}
+.tiptap a {
+  @apply text-blue-600 hover:text-blue-800;
+  text-decoration: none;
+}
+.tiptap a:hover {
+  @apply underline;
+}
+.tiptap ul {
+  @apply list-disc pl-8;
+}
+.tiptap ul li > p {
+  @apply mb-1;
+}
+.tiptap ol {
+  @apply list-decimal pl-7;
+}
+.tiptap ol li > p {
+  @apply mb-1;
+}
+.tiptap blockquote {
+  @apply border-l-4 pl-4 italic text-gray-600 my-4;
+  border-color: #ccc;
+}
+.tiptap code {
+  font-family: monospace;
+}
+.tiptap pre {
+  @apply bg-gray-800 text-gray-500 p-4 rounded-lg overflow-x-auto;
+  font-family: monospace;
+  white-space: pre-wrap;
+  word-wrap: break-word;
+}
+.tiptap img {
+  @apply max-w-full h-auto rounded-lg my-4;
+}
+.tiptap table {
+  @apply table-auto w-full border-collapse mb-4;
+}
+.tiptap th,
+.tiptap td {
+  @apply border px-4 py-2 text-left;
+}
+.tiptap th {
+  @apply bg-gray-500 font-semibold;
+}
+.tiptap tr:nth-child(even) {
+  @apply bg-gray-400;
+}
+@media (max-width: 768px) {
+  .tiptap h1 {
+    @apply text-3xl;
+  }
+  .tiptap h2 {
+    @apply text-2xl;
+  }
+  .tiptap p {
+    @apply text-base;
+  }
+  .tiptap img {
+    @apply max-w-full;
+  }
+}
+
+/*# sourceMappingURL=style.css.map */

package/dist/style.css.map

@@ -0,0 +1 @@
+{"version":3,"sourceRoot":"","sources":["../src/style.scss"],"names":[],"mappings":"AAAA;EACE;;;AAIF;EACE;;;AAGF;EACE;EACA;AACA;;AAEA;EACE;;AAGF;AAAA;AAAA;AAAA;AAAA;AAAA;EAME;EACA;;AAGF;EACE;;AAGF;EACE;;AAGF;EACE;;AAGF;EACE;;AAGF;EACE;;AAGF;EACE;;AAGF;EACE;;AAGF;EACE;EACA;;AAGF;EACE;;AAGF;EACE;;AAEA;EACE;;AAIJ;EACE;;AAEA;EACE;;AAIJ;EACE;EACA;;AAGF;EACE;;AAGF;EACE;EACA;EACA;EACA;;AAGF;EACE;;AAGF;EACE;;AAGF;AAAA;EAEE;;AAGF;EACE;;AAGF;EACE;;AAGF;EACE;IACE;;EAGF;IACE;;EAGF;IACE;;EAGF;IACE","file":"style.css"}

package/dist/utils/DifficultyConverter.d.ts

@@ -0,0 +1,3 @@
+export type LanguageLevel = "Pre-A1" | "A1" | "A2" | "B1" | "B2" | "C1" | "C2" | "Post-C2";
+export declare function getDifficultyLevel(difficulty: LanguageLevel): number;
+export declare function getDifficultyLabel(difficulty: number): LanguageLevel;

package/dist/utils/DifficultyConverter.js

@@ -0,0 +1,7 @@
+const codes = ["Pre-A1", "A1", "A2", "B1", "B2", "C1", "C2", "Post-C2"];
+export function getDifficultyLevel(difficulty) {
+    return codes.indexOf(difficulty) + 1;
+}
+export function getDifficultyLabel(difficulty) {
+    return codes[difficulty];
+}

package/dist/utils/PluginUtils.d.ts

@@ -0,0 +1,2 @@
+export declare function isFullscreen(): boolean;
+export declare function triggerFullscreen(onStateChange: (isFullscreen: boolean) => void, selector?: string): void;

package/dist/utils/PluginUtils.js

@@ -0,0 +1,23 @@
+export function isFullscreen() {
+    return !!document.fullscreenElement;
+}
+export function triggerFullscreen(onStateChange, selector) {
+    document.addEventListener("fullscreenchange", () => {
+        onStateChange(isFullscreen());
+    });
+    try {
+        const ref = document.querySelector(selector || "#root");
+        if (!isFullscreen()) {
+            // @ts-ignore
+            ref.requestFullscreen() || ref.webkitRequestFullscreen();
+        }
+        else {
+            // @ts-ignore
+            document.exitFullscreen() || document.webkitExitFullscreen();
+        }
+    }
+    catch (error) {
+        console.error("Failed to enter fullscreen", error.message);
+    }
+    onStateChange(isFullscreen());
+}

package/dist/utils/constants.d.ts

@@ -0,0 +1,4 @@
+export type Env = typeof env;
+export declare const env: {
+    SUPABASE_URL: string;
+};

package/dist/utils/constants.js

@@ -0,0 +1,12 @@
+// import { unstable_noStore as noStore } from 'next/cache';
+export const env = {
+    // SUPABASE_URL: process?.env?.SUPABASE_URL || "https://pheptqdoqsdnadgoihvr.supabase.co",
+    SUPABASE_URL: "https://pheptqdoqsdnadgoihvr.supabase.co",
+    // SUPABASE_ANON_KEY: process.env.SUPABASE_ANON_KEY,
+};
+// Validate all environment variables are set
+Object.entries(env).forEach(([key, value]) => {
+    if (!value) {
+        throw new Error(`${key} is not set`);
+    }
+});

package/dist/utils/difficultyConverter.d.ts

@@ -0,0 +1,3 @@
+export type LanguageLevel = "Pre-A1" | "A1" | "A2" | "B1" | "B2" | "C1" | "C2" | "Post-C2";
+export declare function getDifficultyLevel(difficulty: LanguageLevel): number;
+export declare function getDifficultyLabel(difficulty: number): LanguageLevel;

package/dist/utils/difficultyConverter.js

@@ -0,0 +1,7 @@
+const codes = ["Pre-A1", "A1", "A2", "B1", "B2", "C1", "C2", "Post-C2"];
+export function getDifficultyLevel(difficulty) {
+    return codes.indexOf(difficulty) + 1;
+}
+export function getDifficultyLabel(difficulty) {
+    return codes[difficulty];
+}

package/dist/utils/plugin/Client.d.ts

@@ -0,0 +1,72 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { GenericSchema } from "@supabase/supabase-js/dist/module/lib/types";
+import { PostgrestQueryBuilder, PostgrestFilterBuilder } from "@supabase/postgrest-js";
+import { PluginController, Tool, ToolInvocation } from "./PluginController";
+import { LanguageLevel } from "../difficultyConverter";
+export declare class RimoriClient {
+    private static instance;
+    private superbase;
+    private plugin;
+    functions: SupabaseClient["functions"];
+    storage: SupabaseClient["storage"];
+    private constructor();
+    static getInstance(pluginController: PluginController): Promise<RimoriClient>;
+    from<TableName extends string & keyof GenericSchema['Tables'], Table extends GenericSchema['Tables'][TableName]>(relation: TableName): PostgrestQueryBuilder<GenericSchema, Table, GenericSchema, Table extends {
+        Relationships: infer R;
+    } ? R : unknown>;
+    /**
+    * Perform a function call.
+    *
+    * @param fn - The function name to call
+    * @param args - The arguments to pass to the function call
+    * @param options - Named parameters
+    * @param options.head - When set to `true`, `data` will not be returned.
+    * Useful if you only need the count.
+    * @param options.get - When set to `true`, the function will be called with
+    * read-only access mode.
+    * @param options.count - Count algorithm to use to count rows returned by the
+    * function. Only applicable for [set-returning
+    * functions](https://www.postgresql.org/docs/current/functions-srf.html).
+    *
+    * `"exact"`: Exact but slow count algorithm. Performs a `COUNT(*)` under the
+    * hood.
+    *
+    * `"planned"`: Approximated but fast count algorithm. Uses the Postgres
+    * statistics under the hood.
+    *
+    * `"estimated"`: Uses exact count for low numbers and planned count for high
+    * numbers.
+    */
+    rpc<FnName extends string & keyof GenericSchema['Functions'], Fn extends GenericSchema['Functions'][FnName]>(fn: FnName, args?: Fn['Args'], options?: {
+        head?: boolean;
+        get?: boolean;
+        count?: 'exact' | 'planned' | 'estimated';
+    }): PostgrestFilterBuilder<GenericSchema, Fn['Returns'] extends any[] ? Fn['Returns'][number] extends Record<string, unknown> ? Fn['Returns'][number] : never : never, Fn['Returns'], FnName, null>;
+    subscribe(eventName: string, callback: (_id: number, data: any) => void): void;
+    request<T>(eventName: string, data: any): Promise<T>;
+    emit(eventName: string, data: any): 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.
+    * @param genericSettings The type of settings to get.
+    * @returns The settings for the plugin.
+    */
+    getSettings<T>(defaultSettings: T, genericSettings?: "user" | "system"): Promise<T>;
+    setSettings(settings: any, genericSettings?: "user" | "system"): Promise<void>;
+    getAIResponse(messages: {
+        role: string;
+        content: string;
+    }[]): Promise<string>;
+    getAIResponseStream(messages: {
+        role: string;
+        content: string;
+    }[], onMessage: (id: string, message: string, finished: boolean, toolInvocations?: ToolInvocation[]) => void, tools?: Tool[]): Promise<void>;
+    getVoiceResponse(text: string, voice?: string, speed?: number, language?: string): Promise<Blob>;
+    getVoiceToTextResponse(file: Blob): Promise<string>;
+}
+export interface UserSettings {
+    motherTongue: string;
+    languageLevel: LanguageLevel;
+}
+export interface SystemSettings {
+}

package/dist/utils/plugin/Client.js

@@ -0,0 +1,118 @@
+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 RimoriClient {
+    constructor(pluginController, superbase) {
+        this.superbase = superbase;
+        this.plugin = pluginController;
+        this.functions = this.superbase.functions;
+        this.storage = this.superbase.storage;
+    }
+    static getInstance(pluginController) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!RimoriClient.instance) {
+                const superbase = yield pluginController.getClient();
+                RimoriClient.instance = new RimoriClient(pluginController, superbase);
+            }
+            return RimoriClient.instance;
+        });
+    }
+    from(relation) {
+        return this.superbase.from(relation);
+    }
+    /**
+    * Perform a function call.
+    *
+    * @param fn - The function name to call
+    * @param args - The arguments to pass to the function call
+    * @param options - Named parameters
+    * @param options.head - When set to `true`, `data` will not be returned.
+    * Useful if you only need the count.
+    * @param options.get - When set to `true`, the function will be called with
+    * read-only access mode.
+    * @param options.count - Count algorithm to use to count rows returned by the
+    * function. Only applicable for [set-returning
+    * functions](https://www.postgresql.org/docs/current/functions-srf.html).
+    *
+    * `"exact"`: Exact but slow count algorithm. Performs a `COUNT(*)` under the
+    * hood.
+    *
+    * `"planned"`: Approximated but fast count algorithm. Uses the Postgres
+    * statistics under the hood.
+    *
+    * `"estimated"`: Uses exact count for low numbers and planned count for high
+    * numbers.
+    */
+    rpc(fn, args = {}, options = {}) {
+        return this.superbase.rpc(fn, args, options);
+    }
+    subscribe(eventName, callback) {
+        this.plugin.subscribe(eventName, callback);
+    }
+    request(eventName, data) {
+        return this.plugin.request(eventName, data);
+    }
+    emit(eventName, data) {
+        this.plugin.emit(eventName, data);
+    }
+    /**
+    * 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.
+    * @param genericSettings The type of settings to get.
+    * @returns The settings for the plugin.
+    */
+    getSettings(defaultSettings, genericSettings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.plugin.request("get_settings", { genericSettings });
+            if (response === null) {
+                this.setSettings(defaultSettings, genericSettings);
+                return defaultSettings;
+                //if the settings are not the same, merge the settings
+            }
+            else if (Object.keys(response).length !== Object.keys(defaultSettings).length) {
+                const existingKeys = Object.fromEntries(Object.entries(response).filter(([k]) => k in defaultSettings));
+                const mergedSettings = Object.assign(Object.assign({}, defaultSettings), existingKeys);
+                console.warn("Settings mismatch", { response, defaultSettings, mergedSettings });
+                this.setSettings(mergedSettings, genericSettings);
+                return mergedSettings;
+            }
+            return response;
+        });
+    }
+    setSettings(settings, genericSettings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.plugin.request("set_settings", { settings, genericSettings });
+        });
+    }
+    getAIResponse(messages) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.plugin.request("getAIResponse", messages);
+        });
+    }
+    getAIResponseStream(messages, onMessage, tools) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error("Not implemented");
+            // let triggered = false;
+            // console.log("getAIResponseStream", messages);
+            // const id = Math.random();
+            // this.internalEmit("getAIResponseStream", id, { messages, tools: tools || [] });
+            // this.subscribe("getAIResponseStream", (_id: number, data: { id: string, response: string, finished: boolean, toolInvocations?: ToolInvocation[] }) => {
+            //     if (triggered || (_id !== id && _id !== 0)) return;
+            //     triggered = data.finished;
+            //     onMessage(data.id, data.response, data.finished, data.toolInvocations);
+            // })
+        });
+    }
+    getVoiceResponse(text, voice = "alloy", speed = 1, language) {
+        return this.plugin.request("getVoiceResponse", { text, voice, speed, language });
+    }
+    getVoiceToTextResponse(file) {
+        return this.plugin.request("getSTTResponse", file);
+    }
+}

package/dist/utils/plugin/PluginController.d.ts

@@ -0,0 +1,36 @@
+import { SupabaseClient } from '@supabase/supabase-js';
+import { RimoriClient } from "./RimoriClient";
+export interface Tool {
+    name: string;
+    description: string;
+    parameters: {
+        name: string;
+        type: "string" | "number" | "boolean";
+        description: string;
+    }[];
+}
+export interface ToolInvocation {
+    toolName: string;
+    args: Record<string, string>;
+}
+export declare class PluginController {
+    private static instance;
+    private static client;
+    private plugin;
+    private onceListeners;
+    private listeners;
+    private communicationSecret;
+    private initialized;
+    private supabase;
+    private accessTokenExpiration;
+    private constructor();
+    static getInstance(): Promise<RimoriClient>;
+    init(): Promise<void>;
+    private getSecret;
+    getClient(): Promise<SupabaseClient<any, "public", any>>;
+    emit(eventName: string, data?: any): void;
+    private internalEmit;
+    subscribe(eventName: string, callback: (_id: number, data: any) => void): void;
+    onOnce(eventName: string, callback: (data: any) => void): void;
+    request<T>(topic: string, data: any): Promise<T>;
+}

package/dist/utils/plugin/PluginController.js

@@ -0,0 +1,119 @@
+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 { Child } from "ibridge-flex";
+import { createClient } from '@supabase/supabase-js';
+import { RimoriClient } from "./RimoriClient";
+export class PluginController {
+    constructor() {
+        // localStorage.debug = "*";
+        this.onceListeners = new Map();
+        this.listeners = new Map();
+        this.communicationSecret = null;
+        this.initialized = false;
+        this.supabase = null;
+        this.accessTokenExpiration = null;
+        this.plugin = new Child({
+            triggerChild: ({ topic, data, _id }) => {
+                var _a, _b;
+                // console.log("trigger child with topic:" + topic + " and data: ", data);
+                (_a = this.onceListeners.get(topic)) === null || _a === void 0 ? void 0 : _a.forEach((callback) => callback(_id, data));
+                this.onceListeners.set(topic, []);
+                (_b = this.listeners.get(topic)) === null || _b === void 0 ? void 0 : _b.forEach((callback) => callback(_id, data));
+            }
+        });
+        // this.init();
+        this.emit = this.emit.bind(this);
+        this.onOnce = this.onOnce.bind(this);
+        this.getClient = this.getClient.bind(this);
+        this.subscribe = this.subscribe.bind(this);
+        this.internalEmit = this.internalEmit.bind(this);
+        this.request = this.request.bind(this);
+    }
+    static getInstance() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!PluginController.instance) {
+                PluginController.instance = new PluginController();
+                yield PluginController.instance.init();
+                PluginController.client = yield RimoriClient.getInstance(PluginController.instance);
+            }
+            return PluginController.client;
+        });
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.initialized) {
+                return;
+            }
+            // Wait for the plugin to be ready
+            yield this.plugin.handshake().then(() => this.initialized = true).catch((error) => {
+                console.error("Failed to initialize the plugin communication:", error);
+            });
+        });
+    }
+    getSecret() {
+        if (!this.communicationSecret) {
+            const secret = new URLSearchParams(window.location.search).get("secret");
+            if (!secret) {
+                throw new Error("Communication secret not found in URL as query parameter");
+            }
+            this.communicationSecret = secret;
+        }
+        return this.communicationSecret;
+    }
+    getClient() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.supabase && this.accessTokenExpiration && this.accessTokenExpiration > new Date()) {
+                return this.supabase;
+            }
+            const response = yield this.request("getSupabaseAccess", {});
+            this.accessTokenExpiration = response.expiration;
+            this.supabase = createClient(response.url, response.key, {
+                accessToken: () => Promise.resolve(response.token)
+            });
+            return this.supabase;
+        });
+    }
+    emit(eventName, data) {
+        this.internalEmit(eventName, 0, data);
+    }
+    // the communication needs to have an id to be able to distinguish between different responses
+    internalEmit(eventName, id, data) {
+        this.init().then(() => this.plugin.emitToParent(eventName, { data, _id: id, secret: this.getSecret() }));
+    }
+    subscribe(eventName, callback) {
+        var _a;
+        if (!this.listeners.has(eventName)) {
+            this.listeners.set(eventName, []);
+        }
+        (_a = this.listeners.get(eventName)) === null || _a === void 0 ? void 0 : _a.push(callback);
+    }
+    onOnce(eventName, callback) {
+        var _a;
+        if (!this.onceListeners.has(eventName)) {
+            this.onceListeners.set(eventName, []);
+        }
+        (_a = this.onceListeners.get(eventName)) === null || _a === void 0 ? void 0 : _a.push(callback);
+    }
+    request(topic, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield new Promise((resolve) => {
+                let triggered = false;
+                const id = Math.random();
+                this.internalEmit(topic, id, data);
+                this.subscribe(topic, (_id, data) => {
+                    if (triggered || (_id !== id && _id !== 0))
+                        return;
+                    triggered = true;
+                    resolve(data);
+                });
+            });
+        });
+    }
+}

package/dist/utils/plugin/PluginUtils.d.ts

@@ -0,0 +1,2 @@
+export declare function isFullscreen(): boolean;
+export declare function triggerFullscreen(onStateChange: (isFullscreen: boolean) => void, selector?: string): void;

package/dist/utils/plugin/PluginUtils.js

@@ -0,0 +1,23 @@
+export function isFullscreen() {
+    return !!document.fullscreenElement;
+}
+export function triggerFullscreen(onStateChange, selector) {
+    document.addEventListener("fullscreenchange", () => {
+        onStateChange(isFullscreen());
+    });
+    try {
+        const ref = document.querySelector(selector || "#root");
+        if (!isFullscreen()) {
+            // @ts-ignore
+            ref.requestFullscreen() || ref.webkitRequestFullscreen();
+        }
+        else {
+            // @ts-ignore
+            document.exitFullscreen() || document.webkitExitFullscreen();
+        }
+    }
+    catch (error) {
+        console.error("Failed to enter fullscreen", error.message);
+    }
+    onStateChange(isFullscreen());
+}