@momo2555/koppeliajs 0.0.161 → 0.0.163

package/dist/components/ResizableText.svelte

@@ -1,26 +1,44 @@
 <script lang="ts">
-    import { routeType } from '../stores/routeStore.js';
+	import { routeType } from '../stores/routeStore.js';
 	import { Koppelia } from '../scripts/koppelia.js';
+	import { onDestroy } from 'svelte';
 
 	export let id: string = '';
-    export let defaultFontSize: number = 10;
+	export let defaultFontSize: number = 10;
 
 	$: fontSize = defaultFontSize;
+	$: callbackId = "";
 
 	let koppelia = Koppelia.instance;
-	
+
 	koppelia.onReady(async () => {
-		await koppelia.registerNewResizableText(id, defaultFontSize, (newFontSize: number) => {
+		let resizableTexts = await koppelia.getResizableTexts();
+		let resizableExist = false;
+		for (let rt of resizableTexts) {
+			if (rt.id !== undefined && rt.id == id) {
+				if (rt.fontSize !== undefined) {
+					fontSize = rt.fontSize;
+				}
+				resizableExist = true;
+				break;
+			}
+		}
+		if (!resizableExist) {
+			await koppelia.registerNewResizableText(id, defaultFontSize);
+		}
+		callbackId = koppelia.onResizableTextChanged(id, (newFontSize: number) => {
 			fontSize = newFontSize;
 		});
 	});
 
+	onDestroy(() => {
+		koppelia.unsubResizableText(callbackId);
+	});
 </script>
 
 <div class="resizable-text" id="resizable-text-{id}" style="font-size: {fontSize}px;">
-    <slot />
+	<slot />
 </div>
 
 <style>
-
 </style>

package/dist/scripts/console.d.ts

@@ -1,6 +1,6 @@
-import { KoppeliaWebsocket, type Callback } from './koppeliaWebsocket.js';
-import { Message, type MessageData, PeerType } from './message.js';
-import type { AnyState } from './state.js';
+import { type Callback, KoppeliaWebsocket } from "./koppeliaWebsocket.js";
+import { Message, type MessageData, PeerType } from "./message.js";
+import type { AnyState } from "./state.js";
 export type ChangeStateCallback = (from: string, state: AnyState, update: boolean) => void;
 export type ChangeStageCallback = (from: string, stage: string) => void;
 export type DataExchangeCallback = (from: string, data: any) => void;
@@ -11,7 +11,8 @@ export type AnyRequestCallback = (request: string, params: {
 }, from: string, address: string) => void;
 export type MediaResponseData = string | Blob | ArrayBuffer | any;
 /**
- * This class define the koppelia console, send and receive requests
+ * Handles the Koppelia console connection, facilitating the sending and receiving of requests
+ * and managing event subscriptions for state changes, device data, and custom logic.
  */
 export declare class Console {
     consoleHostname: string;
@@ -22,62 +23,115 @@ export declare class Console {
     private _deviceDataHandlers;
     private _dataExchangeHandlers;
     private _anyRequestHandlers;
-    private _ready;
     private _onReadyCallback;
+    private _ready;
     private _mediaApiUrl;
     constructor();
     /**
-     * Sdnd a message to the console, set header.to to dispatch the message
-     * @param message
-     * @param callback the callback is called when websocket receives a response
+     * Generates a unique random ID used for registering and tracking callbacks.
+     * @returns A randomly generated string ID.
+     */
+    private _generateId;
+    /**
+     * Unsubscribes a previously registered callback using its unique ID.
+     * @param id The subscription identifier returned by any "on..." listener function.
+     * @returns True if the ID was found and successfully removed, false otherwise.
+     */
+    unsubscribeCallback(id: string): boolean;
+    /**
+     * Dispatches a message through the console socket.
+     * The routing source is automatically appended based on the current application state.
+     * @param message The message payload to send.
+     * @param callback Optional callback triggered when the WebSocket receives a specific response.
      */
     sendMessage(message: Message, callback?: Callback): void;
     /**
-     * Identify the page (controller or monitor) to the console
-     * @param peer
+     * Identifies the current client application (controller or monitor) to the console.
+     * @param peer The peer type to identify as.
      */
     identify(peer: PeerType): void;
+    /**
+     * Retrieves the list of connected devices.
+     * @todo Implementation pending.
+     */
     getConnectedDevices(): void;
     /**
-     * Send data to a peer
-     * @param receiver
-     * @param data
+     * Transmits data payload directly to a specific peer type.
+     * @param receiver The target peer intended to receive the data.
+     * @param data The data payload to transmit.
      */
     sendDataTo(receiver: PeerType, data: MessageData): void;
     /**
-     * Add a callback that will be executed when receive a new state from console
-     * @param callback
+     * Registers a callback to execute whenever a new state is received from the console.
+     * @param callback The function to execute on state change.
+     * @returns The unique subscription ID used for unsubscribing.
+     */
+    onStateChange(callback: ChangeStateCallback): string;
+    /**
+     * Registers a callback to execute whenever the current application stage changes.
+     * @param callback The function to execute on stage change.
+     * @returns The unique subscription ID used for unsubscribing.
+     */
+    onStageChange(callback: ChangeStageCallback): string;
+    /**
+     * Registers a callback to execute when the console connection is fully established and ready.
+     * If the console is already ready at the time of calling, the callback is executed immediately.
+     * @param callback The function to execute upon readiness.
+     * @returns The unique subscription ID used for unsubscribing.
      */
-    onStateChange(callback: ChangeStateCallback): void;
+    onReady(callback: () => void): string;
     /**
-     * Add a callback that will be executed when the current stage has changed
-     * @param callback
+     * Registers a callback to listen for specific device events.
+     * @param callback The function to execute when a device event occurs.
+     * @returns The unique subscription ID used for unsubscribing.
      */
-    onStageChange(callback: ChangeStageCallback): void;
+    onDeviceEvent(callback: DeviceEventCallback): string;
     /**
-     * Add a callback that be called when console is ready, if thec onsole is already ready
-     * Calls directly the function
-     * @param callback
+     * Registers a callback to listen for raw data exchanges between peers.
+     * @param callback The function to execute upon receiving exchanged data.
+     * @returns The unique subscription ID used for unsubscribing.
      */
-    onReady(callback: () => void): void;
-    onDeviceEvent(callback: DeviceEventCallback): void;
-    onDataExchange(callback: DataExchangeCallback): void;
-    onRequest(callback: AnyRequestCallback): void;
+    onDataExchange(callback: DataExchangeCallback): string;
     /**
-     * Get if the connection with the console is ready
+     * Registers a generic callback to intercept and handle custom or unrecognized requests.
+     * @param callback The function to execute for generic requests.
+     * @returns The unique subscription ID used for unsubscribing.
+     */
+    onRequest(callback: AnyRequestCallback): string;
+    /**
+     * Gets the current readiness state of the console WebSocket connection.
      */
     get ready(): boolean;
+    /**
+     * Constructs the full URL for a media asset based on the API port and hostname.
+     * @param path The relative path to the media asset.
+     * @returns The fully qualified URL string.
+     */
     getMediaUrl(path: string): string;
     /**
-     * Call thus function to fix the link and make it work for both controller and monitor
-     * Sometimes, the link is get from monitor or controller and save as a game state. But
-     * When the oher client will get the link will not work. Using this function for all media
-     * Url is a good practice.
-     * @param mediaUrl
+     * Normalizes a media URL to ensure cross-client compatibility.
+     * Corrects edge cases where media links cached in game states by one client (e.g., controller)
+     * fail when accessed by another (e.g., monitor).
+     * @param mediaUrl The raw URL string to fix.
+     * @returns The corrected and standardized URL string.
      */
     fixMediaUrl(mediaUrl: string): string;
+    /**
+     * Fetches a media asset from the API and automatically parses it based on its Content-Type.
+     * @param path The relative path to the media asset.
+     * @returns A promise resolving to the parsed data (JSON, Text, Blob, or ArrayBuffer).
+     * @throws Will throw an error if the HTTP request fails.
+     */
     getMedia(path: string): Promise<MediaResponseData>;
+    /**
+     * Initializes core WebSocket event listeners and maps them to the internal handlers.
+     */
     private _initEvents;
+    /**
+     * Core router for incoming WebSocket data. Decodes the message type and
+     * dispatches it to the corresponding internal execution loops.
+     * @param request The parsed Message object received from the socket.
+     */
     private _processReceivedData;
     private _execDeviceDataHandlers;
     private _execDeviceEventHandlers;
@@ -85,5 +139,8 @@ export declare class Console {
     private _execChangeStageHandlers;
     private _execDataExchangeHandlers;
     private _execAnyRequestHandlers;
+    /**
+     * Hard-resets the application by clearing all registered event handlers.
+     */
     destroyEvents(): void;
 }

package/dist/scripts/console.js

@@ -1,13 +1,14 @@
-import { KoppeliaWebsocket } from './koppeliaWebsocket.js';
-import { Message, PeerType, MessageType } from './message.js';
-import { page } from '$app/stores';
-import { get } from 'svelte/store';
-import { routeType } from '../stores/routeStore.js';
-import { logger } from './logger.js';
+import { KoppeliaWebsocket } from "./koppeliaWebsocket.js";
+import { Message, MessageType, PeerType } from "./message.js";
+import { page } from "$app/stores";
+import { get } from "svelte/store";
+import { routeType } from "../stores/routeStore.js";
+import { logger } from "./logger.js";
 const PORT = 2225;
 const API_PORT = 8000;
 /**
- * This class define the koppelia console, send and receive requests
+ * Handles the Koppelia console connection, facilitating the sending and receiving of requests
+ * and managing event subscriptions for state changes, device data, and custom logic.
  */
 export class Console {
     consoleHostname = "";
@@ -18,8 +19,8 @@ export class Console {
     _deviceDataHandlers;
     _dataExchangeHandlers;
     _anyRequestHandlers;
-    _ready = false;
     _onReadyCallback;
+    _ready = false;
     _mediaApiUrl;
     constructor() {
         this.consoleHostname = "";
@@ -30,44 +31,96 @@ export class Console {
         this.consoleSocket = new KoppeliaWebsocket(consoleUrl);
         this._mediaApiUrl = "http://" + this.consoleHostname + ":" + API_PORT;
         this._ready = false;
-        this._changeStateHandlers = [];
-        this._changeStageHandlers = [];
-        this._deviceEventHandlers = [];
-        this._deviceDataHandlers = [];
-        this._dataExchangeHandlers = [];
-        this._onReadyCallback = [];
-        this._anyRequestHandlers = [];
+        this._changeStateHandlers = {};
+        this._changeStageHandlers = {};
+        this._deviceEventHandlers = {};
+        this._deviceDataHandlers = {};
+        this._dataExchangeHandlers = {};
+        this._onReadyCallback = {};
+        this._anyRequestHandlers = {};
         this._initEvents();
     }
     /**
-     * Sdnd a message to the console, set header.to to dispatch the message
-     * @param message
-     * @param callback the callback is called when websocket receives a response
+     * Generates a unique random ID used for registering and tracking callbacks.
+     * @returns A randomly generated string ID.
+     */
+    _generateId() {
+        return Math.random().toString(36).substring(2, 15) +
+            Math.random().toString(36).substring(2, 15);
+    }
+    /**
+     * Unsubscribes a previously registered callback using its unique ID.
+     * @param id The subscription identifier returned by any "on..." listener function.
+     * @returns True if the ID was found and successfully removed, false otherwise.
+     */
+    unsubscribeCallback(id) {
+        let deleted = false;
+        if (id in this._changeStateHandlers) {
+            delete this._changeStateHandlers[id];
+            deleted = true;
+        }
+        if (id in this._changeStageHandlers) {
+            delete this._changeStageHandlers[id];
+            deleted = true;
+        }
+        if (id in this._deviceEventHandlers) {
+            delete this._deviceEventHandlers[id];
+            deleted = true;
+        }
+        if (id in this._deviceDataHandlers) {
+            delete this._deviceDataHandlers[id];
+            deleted = true;
+        }
+        if (id in this._dataExchangeHandlers) {
+            delete this._dataExchangeHandlers[id];
+            deleted = true;
+        }
+        if (id in this._anyRequestHandlers) {
+            delete this._anyRequestHandlers[id];
+            deleted = true;
+        }
+        if (id in this._onReadyCallback) {
+            delete this._onReadyCallback[id];
+            deleted = true;
+        }
+        return deleted;
+    }
+    /**
+     * Dispatches a message through the console socket.
+     * The routing source is automatically appended based on the current application state.
+     * @param message The message payload to send.
+     * @param callback Optional callback triggered when the WebSocket receives a specific response.
      */
     sendMessage(message, callback) {
         let route = PeerType.NONE;
-        if (get(routeType) == "monitor")
+        if (get(routeType) == "monitor") {
             route = PeerType.MONITOR;
-        else if (get(routeType) == "controller")
+        }
+        else if (get(routeType) == "controller") {
             route = PeerType.CONTROLLER;
+        }
         message.setSource(route, "");
         this.consoleSocket.send(message, callback);
     }
     /**
-     * Identify the page (controller or monitor) to the console
-     * @param peer
+     * Identifies the current client application (controller or monitor) to the console.
+     * @param peer The peer type to identify as.
      */
     identify(peer) {
         let req = new Message();
         req.setIdentification(peer);
         this.consoleSocket.send(req);
     }
+    /**
+     * Retrieves the list of connected devices.
+     * @todo Implementation pending.
+     */
     getConnectedDevices() {
     }
     /**
-     * Send data to a peer
-     * @param receiver
-     * @param data
+     * Transmits data payload directly to a specific peer type.
+     * @param receiver The target peer intended to receive the data.
+     * @param data The data payload to transmit.
      */
     sendDataTo(receiver, data) {
         let req = new Message();
@@ -75,56 +128,93 @@ export class Console {
         req.setDestination(receiver);
     }
     /**
-     * Add a callback that will be executed when receive a new state from console
-     * @param callback
+     * Registers a callback to execute whenever a new state is received from the console.
+     * @param callback The function to execute on state change.
+     * @returns The unique subscription ID used for unsubscribing.
      */
     onStateChange(callback) {
-        this._changeStateHandlers.push(callback);
+        const id = this._generateId();
+        this._changeStateHandlers[id] = callback;
+        return id;
     }
     /**
-     * Add a callback that will be executed when the current stage has changed
-     * @param callback
+     * Registers a callback to execute whenever the current application stage changes.
+     * @param callback The function to execute on stage change.
+     * @returns The unique subscription ID used for unsubscribing.
      */
     onStageChange(callback) {
-        this._changeStageHandlers.push(callback);
+        const id = this._generateId();
+        this._changeStageHandlers[id] = callback;
+        return id;
     }
     /**
-     * Add a callback that be called when console is ready, if thec onsole is already ready
-     * Calls directly the function
-     * @param callback
+     * Registers a callback to execute when the console connection is fully established and ready.
+     * If the console is already ready at the time of calling, the callback is executed immediately.
+     * @param callback The function to execute upon readiness.
+     * @returns The unique subscription ID used for unsubscribing.
      */
     onReady(callback) {
-        if (!this._ready)
-            this._onReadyCallback.push(callback);
-        else
+        const id = this._generateId();
+        if (!this._ready) {
+            this._onReadyCallback[id] = callback;
+        }
+        else {
             callback();
+        }
+        return id;
     }
+    /**
+     * Registers a callback to listen for specific device events.
+     * @param callback The function to execute when a device event occurs.
+     * @returns The unique subscription ID used for unsubscribing.
+     */
     onDeviceEvent(callback) {
-        this._deviceEventHandlers.push(callback);
+        const id = this._generateId();
+        this._deviceEventHandlers[id] = callback;
+        return id;
     }
+    /**
+     * Registers a callback to listen for raw data exchanges between peers.
+     * @param callback The function to execute upon receiving exchanged data.
+     * @returns The unique subscription ID used for unsubscribing.
+     */
     onDataExchange(callback) {
-        this._dataExchangeHandlers.push(callback);
+        const id = this._generateId();
+        this._dataExchangeHandlers[id] = callback;
+        return id;
     }
+    /**
+     * Registers a generic callback to intercept and handle custom or unrecognized requests.
+     * @param callback The function to execute for generic requests.
+     * @returns The unique subscription ID used for unsubscribing.
+     */
     onRequest(callback) {
-        this._anyRequestHandlers.push(callback);
+        const id = this._generateId();
+        this._anyRequestHandlers[id] = callback;
+        return id;
     }
     /**
-     * Get if the connection with the console is ready
+     * Gets the current readiness state of the console WebSocket connection.
      */
     get ready() {
         return this._ready;
     }
+    /**
+     * Constructs the full URL for a media asset based on the API port and hostname.
+     * @param path The relative path to the media asset.
+     * @returns The fully qualified URL string.
+     */
     getMediaUrl(path) {
         if (!path.startsWith("/"))
             path = "/" + path;
         return this._mediaApiUrl + path;
     }
     /**
-     * Call thus function to fix the link and make it work for both controller and monitor
-     * Sometimes, the link is get from monitor or controller and save as a game state. But
-     * When the oher client will get the link will not work. Using this function for all media
-     * Url is a good practice.
-     * @param mediaUrl
+     * Normalizes a media URL to ensure cross-client compatibility.
+     * Corrects edge cases where media links cached in game states by one client (e.g., controller)
+     * fail when accessed by another (e.g., monitor).
+     * @param mediaUrl The raw URL string to fix.
+     * @returns The corrected and standardized URL string.
      */
     fixMediaUrl(mediaUrl) {
         let url = new URL(mediaUrl);
@@ -133,6 +223,12 @@ export class Console {
         fixedurl.search = url.search;
         return fixedurl.toString();
     }
+    /**
+     * Fetches a media asset from the API and automatically parses it based on its Content-Type.
+     * @param path The relative path to the media asset.
+     * @returns A promise resolving to the parsed data (JSON, Text, Blob, or ArrayBuffer).
+     * @throws Will throw an error if the HTTP request fails.
+     */
     async getMedia(path) {
         const response = await fetch(this.getMediaUrl(path));
         if (!response.ok) {
@@ -140,22 +236,26 @@ export class Console {
         }
         const contentType = response.headers.get("Content-Type") || "";
         if (contentType.includes("application/json")) {
-            return await response.json(); // Object
+            return await response.json();
         }
         else if (contentType.startsWith("text/")) {
-            return await response.text(); // String
+            return await response.text();
         }
-        else if (contentType.startsWith("image/") || contentType.includes("application/octet-stream")) {
-            return await response.blob(); // Blob (images, downloads, etc.)
+        else if (contentType.startsWith("image/") ||
+            contentType.includes("application/octet-stream")) {
+            return await response.blob();
         }
         else {
-            return await response.arrayBuffer(); // Generic binary
+            return await response.arrayBuffer();
         }
     }
+    /**
+     * Initializes core WebSocket event listeners and maps them to the internal handlers.
+     */
     _initEvents() {
         this.consoleSocket.onOpen(() => {
             this._ready = true;
-            for (let callback of this._onReadyCallback) {
+            for (let callback of Object.values(this._onReadyCallback)) {
                 callback();
             }
         });
@@ -163,12 +263,17 @@ export class Console {
             this._processReceivedData(request);
         });
     }
+    /**
+     * Core router for incoming WebSocket data. Decodes the message type and
+     * dispatches it to the corresponding internal execution loops.
+     * @param request The parsed Message object received from the socket.
+     */
     _processReceivedData(request) {
-        logger.log("Receive new data from console", request);
-        if (request.header.type === undefined)
+        logger.log("Received new data from console", request);
+        if (request.header.type === undefined) {
             return;
+        }
         let type = request.header.type;
-        /* Handle specific requests */
         if (type == MessageType.REQUEST) {
             switch (request.request.exec) {
                 case "changeState":
@@ -183,53 +288,54 @@ export class Console {
                     break;
             }
         }
-        /* Handle data exchange */
         else if (type == MessageType.DATA_EXCHANGE) {
             this._execDataExchangeHandlers(request.header.from, request.data);
         }
-        /* Handle device event */
         else if (type == MessageType.DEVICE_EVENT) {
             this._execDeviceEventHandlers(request.header.device, request.header.from_addr, request.event);
         }
-        /* Handle device data */
         else if (type == MessageType.DEVICE_DATA) {
             this._execDeviceDataHandlers(request.header.from_addr, request.data);
         }
     }
+    // --- Dictionary execution methods below ---
     _execDeviceDataHandlers(from_addr, data) {
-        for (let handler of this._deviceDataHandlers) {
+        for (let handler of Object.values(this._deviceDataHandlers)) {
             handler(from_addr, data);
         }
     }
     _execDeviceEventHandlers(device, from_addr, event) {
-        for (let handler of this._deviceEventHandlers) {
+        for (let handler of Object.values(this._deviceEventHandlers)) {
             handler(device, from_addr, event);
         }
     }
     _execChangeStateHandlers(from, state, update) {
-        for (let handler of this._changeStateHandlers) {
+        for (let handler of Object.values(this._changeStateHandlers)) {
             handler(from, state, update);
         }
     }
     _execChangeStageHandlers(from, stage) {
-        for (let handler of this._changeStageHandlers) {
+        for (let handler of Object.values(this._changeStageHandlers)) {
             handler(from, stage);
         }
     }
     _execDataExchangeHandlers(from, data) {
-        for (let handler of this._dataExchangeHandlers) {
+        for (let handler of Object.values(this._dataExchangeHandlers)) {
             handler(from, data);
         }
     }
     _execAnyRequestHandlers(request, params, from, address) {
-        for (let handler of this._anyRequestHandlers) {
+        for (let handler of Object.values(this._anyRequestHandlers)) {
             handler(request, params, from, address);
         }
     }
+    /**
+     * Hard-resets the application by clearing all registered event handlers.
+     */
     destroyEvents() {
-        this._deviceEventHandlers = [];
-        this._deviceDataHandlers = [];
-        this._anyRequestHandlers = [];
-        logger.log("destroy events event handlers");
+        this._deviceEventHandlers = {};
+        this._deviceDataHandlers = {};
+        this._anyRequestHandlers = {};
+        logger.log("Destroyed event handlers");
     }
 }

package/dist/scripts/customCallback.d.ts

@@ -1,13 +1,31 @@
 import type { Console } from "./console.js";
+/**
+ * Manages the registration and network-wide execution of custom callbacks.
+ * Allows different nodes in the system to broadcast and react to custom function calls.
+ */
 export declare class CustomCallbacks {
     private _console;
     private _customCallbacks;
     constructor(console: Console);
+    /**
+     * Broadcasts a request across the network to execute a registered custom callback.
+     * @param name The registered name of the custom callback to trigger.
+     * @param args A dictionary of arguments to pass to the callback function.
+     */
     runCustomCallback(name: string, args: {
         [key: string]: any;
     }): void;
+    /**
+     * Registers a local function to be executed when a specific custom callback request is received.
+     * @param name The identifier name for this callback.
+     * @param callback The function to execute when triggered by the network.
+     */
     registerCustomCallback(name: string, callback: (args: {
         [key: string]: any;
     }) => void): void;
+    /**
+     * Removes a previously registered custom callback from the local listener registry.
+     * @param name The identifier name of the callback to remove.
+     */
     unregisterCustomCallback(name: string): void;
 }