@momo2555/koppeliajs 0.0.91

package/README.md

@@ -0,0 +1,110 @@
+# create-svelte
+
+Everything you need to build a Svelte library, powered by [`create-svelte`](https://github.com/sveltejs/kit/tree/main/packages/create-svelte).
+
+Read more about creating a library [in the docs](https://svelte.dev/docs/kit/packaging).
+
+## Creating a project
+
+If you're seeing this, you've probably already done this step. Congrats!
+
+```bash
+# create a new project in the current directory
+npx sv create
+
+# create a new project in my-app
+npx sv create my-app
+```
+
+## Developing
+
+Once you've created a project and installed dependencies with `npm install` (or `pnpm install` or `yarn`), start a development server:
+
+```bash
+npm run dev
+
+# or start the server and open the app in a new browser tab
+npm run dev -- --open
+```
+
+Everything inside `src/lib` is part of your library, everything inside `src/routes` can be used as a showcase or preview app.
+
+## Building
+
+To build your library:
+
+```bash
+npm run package
+```
+
+To create a production version of your showcase app:
+
+```bash
+npm run build
+```
+
+You can preview the production build with `npm run preview`.
+
+> To deploy your app, you may need to install an [adapter](https://svelte.dev/docs/kit/adapters) for your target environment.
+
+## Publishing
+
+Go into the `package.json` and give your package the desired name through the `"name"` option. Also consider adding a `"license"` field and point it to a `LICENSE` file which you can create from a template (one popular option is the [MIT license](https://opensource.org/license/mit/)).
+
+To publish your library to [npm](https://www.npmjs.com):
+
+```bash
+npm publish
+```
+
+```bash
+npm install --save-dev @types/node
+```
+
+# Features of Koppeliajs
+## Monitor and Controller
+**Monitor**: This the screen shown on the tv
+
+**Controller**: This is the screen shown on the smartphone (Koppeli'App)
+
+KoppeliaJS provides tools
+
+## State management
+Manage the state of the game, change easily the state, and get all updates from the server
+
+## Stage management
+A stage is a part of the game (it is a page), when the stage changes, it changes for the controller and monitor
+
+## Device management
+Manage the devices connected to the console.
+
+## Play management
+Manage the plays of the game. You can create new plays for a specific game on KOppelia'App.
+
+## difficulty Cursor
+Change the difficulty of the game in real time. The DifficultyCurser option should be activated on KoppeliaJS.
+
+## Growable Element
+Growable elements are elements (generally text) that are shown on the monitor screen. Those elements can be expanded from the controller. They will take all the surface of the monitor screen.
+
+## Resizable Text
+Resizable text are text shwon on monitor screen and the font size can be changed in real time from Koppeli'App
+
+## ScrollSyncer
+
+## StageButton
+
+# Start a new project with Koppelia js
+
+## Create a new project with npm
+
+## Install sveltekit library
+
+## Install koppeliajs library
+
+## Minimum required files (file tree)
+
+## Run your game
+
+## dockerize
+

package/dist/components/DynamicCursor.svelte.d.ts

@@ -0,0 +1,26 @@
+export default DynamicCursor;
+type DynamicCursor = SvelteComponent<{
+    [x: string]: never;
+}, {
+    [evt: string]: CustomEvent<any>;
+}, {}> & {
+    $$bindings?: string | undefined;
+};
+declare const DynamicCursor: $$__sveltets_2_IsomorphicComponent<{
+    [x: string]: never;
+}, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import("svelte").ComponentConstructorOptions<Props>): import("svelte").SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}

package/dist/components/DynamicTextField.svelte.d.ts

@@ -0,0 +1,26 @@
+export default DynamicTextField;
+type DynamicTextField = SvelteComponent<{
+    [x: string]: never;
+}, {
+    [evt: string]: CustomEvent<any>;
+}, {}> & {
+    $$bindings?: string | undefined;
+};
+declare const DynamicTextField: $$__sveltets_2_IsomorphicComponent<{
+    [x: string]: never;
+}, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import("svelte").ComponentConstructorOptions<Props>): import("svelte").SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}

package/dist/components/GrowableElement.svelte

@@ -0,0 +1,62 @@
+<script lang="ts">
+	import { routeType } from '../stores/routeStore.js';
+	import { Koppelia } from '../scripts/koppelia.js';
+
+	export let id: string = '';
+
+	$: grownClass = '';
+
+	let koppelia = Koppelia.instance;
+	
+	koppelia.onReady(async () => {
+		await koppelia.registerNewGrowableElement(id, (grown: boolean) => {
+			grownClass = grown ? 'top-growable-grown' : '';
+		});
+	});
+
+	function onElementClick() {
+		koppelia.updateGrowableElement(id, true);
+	}
+
+	function onCloseGrown() {
+		koppelia.updateGrowableElement(id, false);
+	}
+</script>
+
+<button {id} on:click={onElementClick}>
+	<slot />
+</button>
+
+<div class="top-growable {grownClass}" id="top-growable-{id}">
+	{#if $routeType == 'controller'}
+		<button on:click={onCloseGrown} class="top-growable-close-button"> x </button>
+	{/if}
+
+	<slot />
+</div>
+
+<style>
+	.top-growable {
+		width: 90%;
+		height: 90%;
+		z-index: 99999;
+		position: absolute;
+		top: 5%;
+		left: 5%;
+		border: 1px solid #362a24;
+		background-color: antiquewhite;
+		margin: auto;
+		display: none;
+	}
+
+	.top-growable-close-button {
+		position: absolute;
+		left: 5px;
+		top: 5px;
+		color: #362a24;
+	}
+
+	.top-growable-grown {
+		display: flex;
+	}
+</style>

package/dist/components/GrowableElement.svelte.d.ts

@@ -0,0 +1,29 @@
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: Props & {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+type $$__sveltets_2_PropsWithChildren<Props, Slots> = Props & (Slots extends {
+    default: any;
+} ? Props extends Record<string, never> ? any : {
+    children?: any;
+} : {});
+declare const GrowableElement: $$__sveltets_2_IsomorphicComponent<$$__sveltets_2_PropsWithChildren<{
+    id?: string;
+}, {
+    default: {};
+}>, {
+    [evt: string]: CustomEvent<any>;
+}, {
+    default: {};
+}, {}, string>;
+type GrowableElement = InstanceType<typeof GrowableElement>;
+export default GrowableElement;

package/dist/components/KBase.svelte

@@ -0,0 +1,8 @@
+<script lang="ts">
+    import { routeType } from '../stores/routeStore.js'
+    $: route = $routeType;
+
+</script>
+
+<slot {route}/>
+

package/dist/components/KBase.svelte.d.ts

@@ -0,0 +1,22 @@
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+declare const KBase: $$__sveltets_2_IsomorphicComponent<any, {
+    [evt: string]: CustomEvent<any>;
+}, {
+    default: {
+        route: string;
+    };
+}, {}, string>;
+type KBase = InstanceType<typeof KBase>;
+export default KBase;

package/dist/components/KButton.svelte.d.ts

@@ -0,0 +1,26 @@
+export default KButton;
+type KButton = SvelteComponent<{
+    [x: string]: never;
+}, {
+    [evt: string]: CustomEvent<any>;
+}, {}> & {
+    $$bindings?: string | undefined;
+};
+declare const KButton: $$__sveltets_2_IsomorphicComponent<{
+    [x: string]: never;
+}, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import("svelte").ComponentConstructorOptions<Props>): import("svelte").SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}

package/dist/components/Koppelia.svelte

@@ -0,0 +1,11 @@
+<script lang="ts">
+    import { routeType } from '../stores/routeStore.js';
+</script>
+
+<div class={$routeType}>
+    <slot />
+</div>
+
+<style>
+
+</style>

package/dist/components/Koppelia.svelte.d.ts

@@ -0,0 +1,20 @@
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+declare const Koppelia: $$__sveltets_2_IsomorphicComponent<any, {
+    [evt: string]: CustomEvent<any>;
+}, {
+    default: {};
+}, {}, string>;
+type Koppelia = InstanceType<typeof Koppelia>;
+export default Koppelia;

package/dist/components/ResizableText.svelte.d.ts

@@ -0,0 +1,26 @@
+export default ResizableText;
+type ResizableText = SvelteComponent<{
+    [x: string]: never;
+}, {
+    [evt: string]: CustomEvent<any>;
+}, {}> & {
+    $$bindings?: string | undefined;
+};
+declare const ResizableText: $$__sveltets_2_IsomorphicComponent<{
+    [x: string]: never;
+}, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import("svelte").ComponentConstructorOptions<Props>): import("svelte").SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import KBase from "./components/KBase.svelte";
+import GrowableElement from "./components/GrowableElement.svelte";
+import { Koppelia } from "./scripts/koppelia.js";
+import { Console } from "./scripts/console.js";
+import { Message } from "./scripts/message.js";
+import { Device } from "./scripts/device.js";
+import { Play } from "./scripts/play.js";
+import { updateRoute, routeType } from './stores/routeStore.js';
+import { gameState } from "./stores/stateStore.js";
+export { KBase };
+export { updateRoute, routeType, Koppelia, Console, Message, Device, gameState, Play, GrowableElement };

package/dist/index.js

@@ -0,0 +1,12 @@
+// Reexport your entry components here
+import KBase from "./components/KBase.svelte";
+import GrowableElement from "./components/GrowableElement.svelte";
+import { Koppelia } from "./scripts/koppelia.js";
+import { Console } from "./scripts/console.js";
+import { Message } from "./scripts/message.js";
+import { Device } from "./scripts/device.js";
+import { Play } from "./scripts/play.js";
+import { updateRoute, routeType } from './stores/routeStore.js';
+import { gameState } from "./stores/stateStore.js";
+export { KBase }; // Compoenents
+export { updateRoute, routeType, Koppelia, Console, Message, Device, gameState, Play, GrowableElement }; //  libraries and stores

package/dist/scripts/console.d.ts

@@ -0,0 +1,75 @@
+import { KoppeliaWebsocket, type Callback } from './koppeliaWebsocket.js';
+import { Message, type MessageData, PeerType } from './message.js';
+import type { AnyState } from './state.js';
+export type ChangeStateCallback = (from: string, state: AnyState) => void;
+export type ChangeStageCallback = (from: string, stage: string) => void;
+export type DataExchangeCallback = (from: string, data: any) => void;
+export type DeviceEventCallback = (device: string, from_addr: string, event: string) => void;
+export type DeviceDataCallback = (device: string, from_addr: string, event: string) => void;
+export type AnyRequestCallback = (request: string, params: {
+    [key: string]: any;
+}, from: string, address: string) => void;
+/**
+ * This class define the koppelia console, send and receive requests
+ */
+export declare class Console {
+    consoleHostname: string;
+    consoleSocket: KoppeliaWebsocket;
+    private _changeStateHandlers;
+    private _changeStageHandlers;
+    private _deviceEventHandlers;
+    private _deviceDataHandlers;
+    private _dataExchangeHandlers;
+    private _anyRequestHandlers;
+    private _ready;
+    private _onReadyCallback;
+    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
+     */
+    sendMessage(message: Message, callback?: Callback): void;
+    /**
+     * Identify the page (controller or monitor) to the console
+     * @param peer
+     */
+    identify(peer: PeerType): void;
+    getConnectedDevices(): void;
+    /**
+     * Send data to a peer
+     * @param receiver
+     * @param data
+     */
+    sendDataTo(receiver: PeerType, data: MessageData): void;
+    /**
+     * Add a callback that will be executed when receive a new state from console
+     * @param callback
+     */
+    onStateChange(callback: ChangeStateCallback): void;
+    /**
+     * Add a callback that will be executed when the current stage has changed
+     * @param callback
+     */
+    onStageChange(callback: ChangeStageCallback): void;
+    /**
+     * Add a callback that be called when console is ready, if thec onsole is already ready
+     * Calls directly the function
+     * @param callback
+     */
+    onReady(callback: () => void): void;
+    onDeviceEvent(callback: () => void): void;
+    onRequest(callback: AnyRequestCallback): void;
+    /**
+     * Get if the connection with the console is ready
+     */
+    get ready(): boolean;
+    private _initEvents;
+    private _processReceivedData;
+    private _execDeviceDataHandlers;
+    private _execDeviceEventHandlers;
+    private _execChangeStateHandlers;
+    private _execChangeStageHandlers;
+    private _execDataExchangeHandlers;
+    private _execAnyRequestHandlers;
+}

package/dist/scripts/console.js

@@ -0,0 +1,180 @@
+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';
+const PORT = 2225;
+/**
+ * This class define the koppelia console, send and receive requests
+ */
+export class Console {
+    consoleHostname = "";
+    consoleSocket;
+    _changeStateHandlers;
+    _changeStageHandlers;
+    _deviceEventHandlers;
+    _deviceDataHandlers;
+    _dataExchangeHandlers;
+    _anyRequestHandlers;
+    _ready = false;
+    _onReadyCallback;
+    constructor() {
+        this.consoleHostname = get(page).url.hostname;
+        let consoleUrl = "ws://" + this.consoleHostname + ":" + PORT;
+        this.consoleSocket = new KoppeliaWebsocket(consoleUrl);
+        this._ready = false;
+        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
+     */
+    sendMessage(message, callback) {
+        let route = PeerType.NONE;
+        if (get(routeType) == "monitor")
+            route = PeerType.MONITOR;
+        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
+     */
+    identify(peer) {
+        let req = new Message();
+        req.setIdentification(peer);
+        this.consoleSocket.send(req);
+    }
+    getConnectedDevices() {
+    }
+    /**
+     * Send data to a peer
+     * @param receiver
+     * @param data
+     */
+    sendDataTo(receiver, data) {
+        let req = new Message();
+        req.setData(data);
+        req.setDestination(receiver);
+    }
+    /**
+     * Add a callback that will be executed when receive a new state from console
+     * @param callback
+     */
+    onStateChange(callback) {
+        this._changeStateHandlers.push(callback);
+    }
+    /**
+     * Add a callback that will be executed when the current stage has changed
+     * @param callback
+     */
+    onStageChange(callback) {
+        this._changeStageHandlers.push(callback);
+    }
+    /**
+     * Add a callback that be called when console is ready, if thec onsole is already ready
+     * Calls directly the function
+     * @param callback
+     */
+    onReady(callback) {
+        if (!this._ready)
+            this._onReadyCallback.push(callback);
+        else
+            callback();
+    }
+    onDeviceEvent(callback) {
+        this._deviceEventHandlers.push(callback);
+    }
+    onRequest(callback) {
+        this._anyRequestHandlers.push(callback);
+    }
+    /**
+     * Get if the connection with the console is ready
+     */
+    get ready() {
+        return this._ready;
+    }
+    _initEvents() {
+        this.consoleSocket.onOpen(() => {
+            this._ready = true;
+            for (let callback of this._onReadyCallback) {
+                callback();
+            }
+        });
+        this.consoleSocket.onReceive((request) => {
+            this._processReceivedData(request);
+        });
+    }
+    _processReceivedData(request) {
+        console.log("Receive 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":
+                    this._execChangeStateHandlers(request.header.from, request.request.params.state);
+                    break;
+                case "changeStage":
+                    this._execChangeStageHandlers(request.header.from, request.request.params.stage);
+                    break;
+                default:
+                    this._execAnyRequestHandlers(request.request.exec, request.request.params, request.header.from, request.header.from_addr);
+                    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);
+        }
+    }
+    _execDeviceDataHandlers(from_addr, data) {
+        for (let handler of this._deviceDataHandlers) {
+            handler(from_addr, data);
+        }
+    }
+    _execDeviceEventHandlers(device, from_addr, event) {
+        for (let handler of this._deviceEventHandlers) {
+            handler(device, from_addr, event);
+        }
+    }
+    _execChangeStateHandlers(from, state) {
+        for (let handler of this._changeStateHandlers) {
+            handler(from, state);
+        }
+    }
+    _execChangeStageHandlers(from, stage) {
+        for (let handler of this._changeStageHandlers) {
+            handler(from, stage);
+        }
+    }
+    _execDataExchangeHandlers(from, data) {
+        for (let handler of this._dataExchangeHandlers) {
+            handler(from, data);
+        }
+    }
+    _execAnyRequestHandlers(request, params, from, address) {
+        for (let handler of this._anyRequestHandlers) {
+            handler(request, params, from, address);
+        }
+    }
+}