@momo2555/koppeliajs 0.0.91

package/dist/scripts/message.d.ts

@@ -0,0 +1,116 @@
+export type AnyRequest = {
+    [key: string]: any;
+};
+export declare enum PeerType {
+    MONITOR = "monitor",
+    MASTER = "master",
+    CONTROLLER = "controller",
+    DEVICE = "device",
+    SPECTAKLE = "spectakle",
+    KOPPELIA = "koppelia",
+    NONE = "none"
+}
+export declare enum MessageType {
+    EMPTY = "empty",
+    REQUEST = "request",
+    RESPONSE = "response",
+    DATA_EXCHANGE = "data_exchange",
+    DEVICE_EVENT = "device_event",
+    DEVICE_DATA = "device_data",
+    IDENTIFICATION = "identification",
+    MODULE_ENABLE = "module_enable",
+    ERROR = "error"
+}
+type MessagetHeader = {
+    id: string;
+    type: string;
+    from: string;
+    to: string;
+    from_addr: string;
+    to_addr: string;
+    device: string;
+};
+export type MessageData = {
+    [key: string]: string;
+};
+type MessageEvent = string;
+type DirectRequest = {
+    exec: string;
+    params: {
+        [key: string]: any;
+    };
+};
+/**
+ * The koppelia protocol
+ */
+export declare class Message {
+    header: MessagetHeader;
+    data: MessageData;
+    request: DirectRequest;
+    event: MessageEvent;
+    constructor();
+    /**
+     * Parse a json request received from the network
+     * @param data
+     */
+    parse(data: AnyRequest): void;
+    /**
+     * Convert the request to json, to be sent on the network
+     * @returns
+     */
+    toObject(): AnyRequest;
+    /**
+     * Set the source device, type and address (if there is address)
+     * @param type
+     * @param address
+     */
+    setSource(type: PeerType, address?: string): void;
+    /**
+     * Set the destination device, type and address
+     * @param type
+     * @param address
+     */
+    setDestination(type: PeerType, address?: string): void;
+    /**
+     * Get event name of the request, if it is an event
+     * @returns
+     */
+    getEvent(): MessageEvent;
+    /**
+     * Set the type of the request
+     * @param type
+     */
+    setType(type: MessageType): void;
+    /**
+     * Set an event to the request
+     * @param event
+     */
+    setEvent(event: MessageEvent): void;
+    /**
+     * Add a param if the request is request type
+     * @param key
+     * @param value
+     */
+    addParam(key: string, value: any): void;
+    /**
+     * Add data to the request
+     * @param key
+     * @param value
+     */
+    addData(key: string, value: any): void;
+    /**
+     *
+     * @param data
+     */
+    setData(data: MessageData): void;
+    /**
+     * Set a new request with a request name
+     * @param execName name of
+     */
+    setRequest(execName: string): void;
+    getParam(paramName: string, def?: any): any;
+    setIdentification(peerToIdentify: PeerType): void;
+    generateRequestId(): void;
+    getRequestId(): string;
+}
+export {};

package/dist/scripts/message.js

@@ -0,0 +1,178 @@
+export var PeerType;
+(function (PeerType) {
+    PeerType["MONITOR"] = "monitor";
+    PeerType["MASTER"] = "master";
+    PeerType["CONTROLLER"] = "controller";
+    PeerType["DEVICE"] = "device";
+    PeerType["SPECTAKLE"] = "spectakle";
+    PeerType["KOPPELIA"] = "koppelia";
+    PeerType["NONE"] = "none";
+})(PeerType || (PeerType = {}));
+;
+export var MessageType;
+(function (MessageType) {
+    MessageType["EMPTY"] = "empty";
+    MessageType["REQUEST"] = "request";
+    MessageType["RESPONSE"] = "response";
+    MessageType["DATA_EXCHANGE"] = "data_exchange";
+    MessageType["DEVICE_EVENT"] = "device_event";
+    MessageType["DEVICE_DATA"] = "device_data";
+    MessageType["IDENTIFICATION"] = "identification";
+    MessageType["MODULE_ENABLE"] = "module_enable";
+    MessageType["ERROR"] = "error";
+})(MessageType || (MessageType = {}));
+/**
+ * The koppelia protocol
+ */
+export class Message {
+    header;
+    data;
+    request;
+    event;
+    constructor() {
+        this.header = {
+            id: "",
+            type: MessageType.EMPTY,
+            from: PeerType.NONE,
+            to: PeerType.NONE,
+            from_addr: "",
+            to_addr: "",
+            device: "",
+        };
+        this.data = {};
+        this.request = {
+            exec: "",
+            params: {}
+        };
+        this.event = "";
+    }
+    /**
+     * Parse a json request received from the network
+     * @param data
+     */
+    parse(data) {
+        if (data.header !== undefined) {
+            for (let key in data.header) {
+                if (key in this.header) {
+                    this.header[key] = data.header[key];
+                }
+            }
+        }
+        if (data.data !== undefined) {
+            this.data = data.data;
+        }
+        if (data.event !== undefined && typeof data.event === "string") {
+            this.event = data.event;
+        }
+        if (data.request !== undefined) {
+            if (data.request.exec !== undefined) {
+                this.request.exec = data.request.exec;
+            }
+            if (data.request.params !== undefined) {
+                this.request.params = data.request.params;
+            }
+        }
+    }
+    /**
+     * Convert the request to json, to be sent on the network
+     * @returns
+     */
+    toObject() {
+        return {
+            header: this.header,
+            request: this.request,
+            data: this.data,
+            event: this.event
+        };
+    }
+    /**
+     * Set the source device, type and address (if there is address)
+     * @param type
+     * @param address
+     */
+    setSource(type, address = "") {
+        this.header.from = type;
+        this.header.from_addr = address;
+    }
+    /**
+     * Set the destination device, type and address
+     * @param type
+     * @param address
+     */
+    setDestination(type, address = "") {
+        this.header.to = type;
+        this.header.to_addr = address;
+    }
+    /**
+     * Get event name of the request, if it is an event
+     * @returns
+     */
+    getEvent() {
+        return this.event;
+    }
+    /**
+     * Set the type of the request
+     * @param type
+     */
+    setType(type) {
+        this.header.type = type;
+    }
+    /**
+     * Set an event to the request
+     * @param event
+     */
+    setEvent(event) {
+        this.header.type = MessageType.REQUEST;
+        this.event = event;
+    }
+    /**
+     * Add a param if the request is request type
+     * @param key
+     * @param value
+     */
+    addParam(key, value) {
+        this.request.params[key] = value;
+    }
+    /**
+     * Add data to the request
+     * @param key
+     * @param value
+     */
+    addData(key, value) {
+        this.data[key] = value;
+    }
+    /**
+     *
+     * @param data
+     */
+    setData(data) {
+        this.data = data;
+    }
+    /**
+     * Set a new request with a request name
+     * @param execName name of
+     */
+    setRequest(execName) {
+        this.header.type = MessageType.REQUEST;
+        this.request.exec = execName;
+    }
+    getParam(paramName, def = null) {
+        if (paramName in this.request.params) {
+            return this.request.params[paramName];
+        }
+        else {
+            return def;
+        }
+    }
+    setIdentification(peerToIdentify) {
+        this.header.type = MessageType.IDENTIFICATION;
+        this.header.from = peerToIdentify;
+    }
+    generateRequestId() {
+        this.header.id = crypto.randomUUID();
+        ;
+    }
+    getRequestId() {
+        return this.header.id;
+    }
+}

package/dist/scripts/play.d.ts

@@ -0,0 +1,49 @@
+import { Console } from "./console.js";
+export declare class Play {
+    private _playCreationDate;
+    private _playCreatorId;
+    private _playFileName;
+    private _playGameId;
+    private _playIsPrivate;
+    private _playImagebase64;
+    private _playMedias;
+    private _playName;
+    private _playId;
+    private _playData;
+    private _base64Medias;
+    private _console;
+    private _refreshed;
+    constructor(console: Console, playId: string, playRawObj: {
+        [key: string]: any;
+    });
+    refresh(): Promise<void>;
+    /**
+     * Get the list of all media files of the play
+     */
+    get mediasList(): string[];
+    /**
+     * Get the media file by using its name. This function returns a base64 file
+     * @param mediaName
+     * @returns
+     */
+    getMedia(mediaName: string): string | undefined;
+    /**
+     * Get the data of the play
+     */
+    get data(): {
+        [key: string]: any;
+    };
+    /**
+     * Get the id of the play
+     */
+    get id(): string;
+    /**
+     * Get the name of the play
+     */
+    get name(): string;
+    /**
+     * Get the image base64
+     */
+    get image(): string;
+    get isRefreshed(): boolean;
+}

package/dist/scripts/play.js

@@ -0,0 +1,107 @@
+import { Console } from "./console.js";
+import { Message, PeerType } from "./message.js";
+export class Play {
+    _playCreationDate = "";
+    _playCreatorId = "";
+    _playFileName = "";
+    _playGameId = "";
+    _playIsPrivate = "";
+    _playImagebase64 = "";
+    _playMedias = [];
+    _playName = "";
+    _playId = "";
+    _playData = {};
+    _base64Medias = {};
+    _console;
+    _refreshed = true;
+    constructor(console, playId, playRawObj) {
+        this._console = console;
+        this._playId = playId;
+        if (playRawObj._play_data_json !== undefined) {
+            this._playData = playRawObj._play_data_json;
+            this._refreshed = true;
+        }
+        ;
+        if (playRawObj._play_medias_raw !== undefined) {
+            this._base64Medias = playRawObj._play_medias_raw;
+        }
+        if (playRawObj.playName !== undefined) {
+            this._playName = playRawObj.playName;
+        }
+        if (playRawObj.playMedias !== undefined) {
+            this._playMedias = playRawObj.playMedias;
+        }
+        if (playRawObj._play_image_raw !== undefined) {
+            this._playImagebase64 = playRawObj._play_image_raw;
+        }
+    }
+    async refresh() {
+        return new Promise((resolve, reject) => {
+            let getPlaysRequest = new Message();
+            getPlaysRequest.setRequest("getPlayRaw");
+            getPlaysRequest.addParam("playId", this.id);
+            getPlaysRequest.setDestination(PeerType.MASTER, "");
+            this._console.sendMessage(getPlaysRequest, (response) => {
+                let playRawObj = response.getParam("play", {});
+                if (playRawObj._play_data_json !== undefined) {
+                    this._playData = playRawObj._play_data_json;
+                    this._refreshed = true;
+                }
+                ;
+                if (playRawObj._play_medias_raw !== undefined) {
+                    this._base64Medias = playRawObj._play_medias_raw;
+                }
+                if (playRawObj._play_image_raw !== undefined) {
+                    this._playImagebase64 = playRawObj._play_image_raw;
+                }
+                resolve();
+            });
+        });
+    }
+    /**
+     * Get the list of all media files of the play
+     */
+    get mediasList() {
+        return Object.keys(this._base64Medias);
+    }
+    /**
+     * Get the media file by using its name. This function returns a base64 file
+     * @param mediaName
+     * @returns
+     */
+    getMedia(mediaName) {
+        if (this._base64Medias[mediaName] !== undefined) {
+            return this._base64Medias[mediaName];
+        }
+        else {
+            return undefined;
+        }
+    }
+    /**
+     * Get the data of the play
+     */
+    get data() {
+        return this._playData;
+    }
+    /**
+     * Get the id of the play
+     */
+    get id() {
+        return this._playId;
+    }
+    /**
+     * Get the name of the play
+     */
+    get name() {
+        return this._playName;
+    }
+    /**
+     * Get the image base64
+     */
+    get image() {
+        return this._playImagebase64;
+    }
+    get isRefreshed() {
+        return this._refreshed;
+    }
+}

package/dist/scripts/stage.d.ts

@@ -0,0 +1,12 @@
+import { Console } from "./console.js";
+export declare class Stage {
+    private _currentStage;
+    private _stages;
+    private _console;
+    constructor(console: Console);
+    updateFromServer(): void;
+    initStages(stages: string[]): void;
+    goto(stage: string): void;
+    private _initEvents;
+    private _onReceiveStage;
+}

package/dist/scripts/stage.js

@@ -0,0 +1,38 @@
+import { Console } from "./console.js";
+import { Message } from "./message.js";
+import { goto } from "$app/navigation";
+import { routeType } from "../stores/routeStore.js";
+import { get } from "svelte/store";
+export class Stage {
+    _currentStage = "home";
+    _stages = ["home"];
+    _console;
+    constructor(console) {
+        this._console = console;
+        this._initEvents();
+    }
+    updateFromServer() {
+    }
+    initStages(stages) {
+        let req = new Message();
+        req.setRequest("initStages");
+        req.addParam("stages", stages);
+        this._console.sendMessage(req);
+    }
+    goto(stage) {
+        let req = new Message();
+        req.setRequest("changeStage");
+        req.addParam("stage", stage);
+        this._console.sendMessage(req);
+    }
+    _initEvents() {
+        // update the state when receive a change from console
+        this._console.onStageChange((from, stage) => {
+            this._onReceiveStage(from, stage);
+        });
+    }
+    _onReceiveStage(from, receivedStage) {
+        let path = "/game/" + get(routeType) + "/" + receivedStage;
+        goto(path);
+    }
+}

package/dist/scripts/state.d.ts

@@ -0,0 +1,36 @@
+import { Console } from "./console.js";
+import { type Writable } from "svelte/store";
+export type AnyState = {
+    [key: string]: string;
+};
+export declare class State {
+    private _globalState;
+    private _console;
+    private _access;
+    constructor(console: Console, defaultState?: AnyState);
+    get state(): Writable<AnyState>;
+    /**
+     * Update the state from the server
+     */
+    updateFromServer(): void;
+    /**
+     * Force change the state with a new one
+     * @param newState
+     */
+    setState(newState: AnyState): void;
+    /**
+     * Marge a new update to the last one
+     * @param stateUpdate
+     */
+    updateState(stateUpdate: AnyState): void;
+    /**
+     * Init all events
+     * @param from
+     * @param any
+     */
+    private _initEvents;
+    /**
+     * callback when a new state
+     */
+    private _onReceiveState;
+}

package/dist/scripts/state.js

@@ -0,0 +1,82 @@
+import { Console } from "./console.js";
+import { Message } from "./message.js";
+import { get, writable } from "svelte/store";
+export class State {
+    _globalState;
+    _console;
+    _access = true;
+    constructor(console, defaultState = {}) {
+        this._access = false;
+        this._globalState = writable(defaultState);
+        this._console = console;
+        this._initEvents();
+        this._access = true;
+    }
+    get state() {
+        return this._globalState;
+    }
+    /**
+     * Update the state from the server
+     */
+    updateFromServer() {
+        let req = new Message();
+        req.setRequest("getState");
+        this._console.sendMessage(req, (response) => {
+            let state = response.getParam('state', {});
+            this._onReceiveState(response.header.from, state);
+        });
+    }
+    /**
+     * Force change the state with a new one
+     * @param newState
+     */
+    setState(newState) {
+        this._globalState.set(newState);
+    }
+    /**
+     * Marge a new update to the last one
+     * @param stateUpdate
+     */
+    updateState(stateUpdate) {
+        let tempState = get(this._globalState);
+        for (let key in stateUpdate) {
+            tempState[key] = stateUpdate[key];
+        }
+        this.setState(tempState);
+    }
+    /**
+     * Init all events
+     * @param from
+     * @param any
+     */
+    _initEvents() {
+        // Get the state when the console is ready
+        this._console.onReady(() => {
+            this.updateFromServer();
+        });
+        // update the state when receive a change from console
+        this._console.onStateChange((from, state) => {
+            this._onReceiveState(from, state);
+        });
+        // Send a change state request when detect a state change
+        this._globalState.subscribe((newState) => {
+            if (this._access) {
+                this._console.onReady(() => {
+                    console.log("change state new state", newState);
+                    let req = new Message();
+                    req.setRequest("changeState");
+                    req.addParam("state", newState);
+                    this._console.sendMessage(req);
+                });
+            }
+        });
+    }
+    /**
+     * callback when a new state
+     */
+    _onReceiveState(from, receivedState) {
+        this._access = false;
+        this._globalState.set(receivedState);
+        this._access = true;
+    }
+}

package/dist/scripts/utils.d.ts

@@ -0,0 +1 @@
+export declare function valueToEnum<T extends Record<string, any>>(enumObj: T, value: string | number): T[keyof T] | undefined;

package/dist/scripts/utils.js

@@ -0,0 +1,5 @@
+export function valueToEnum(enumObj, value) {
+    const entries = Object.entries(enumObj);
+    const found = entries.find(([_, enumValue]) => enumValue === value);
+    return found ? enumObj[found[0]] : undefined;
+}

package/dist/server/index.d.ts

@@ -0,0 +1,2 @@
+import { KoppeliaServerApi } from "./koppeliaServerApi.js";
+export { KoppeliaServerApi };

package/dist/server/index.js

@@ -0,0 +1,2 @@
+import { KoppeliaServerApi } from "./koppeliaServerApi.js";
+export { KoppeliaServerApi }; // Server side libraries

package/dist/server/koppeliaServerApi.d.ts

@@ -0,0 +1,7 @@
+export declare class KoppeliaServerApi {
+    path: string;
+    constructor(path: string);
+    run(): void;
+    getContentType(file: string): string;
+    serveApi(): void;
+}