graphos-world-client 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+import type { IObject, ISendEvent } from "./types.js";
+export declare class SpawnEvent extends Event {
+    readonly object: IObject;
+    constructor(object: IObject);
+}
+export declare class DespawnEvent extends Event {
+    readonly object: IObject;
+    constructor(object: IObject);
+}
+export declare class ChangeEvent extends Event {
+    readonly object: IObject;
+    readonly changes: Partial<IObject>;
+    constructor(object: IObject, changes: Partial<IObject>);
+}
+type ObjectIterator<T> = IterableIterator<T>;
+export declare function getDeviceId(): string;
+export declare class Client extends EventTarget {
+    readonly url: string;
+    private _window;
+    private _socket;
+    private _isConnected;
+    private _objects;
+    constructor(url?: string);
+    private onSocketConnect;
+    private onWorldEventRecordClear;
+    protected onDataBindingChange(object: IObject, v: Partial<IObject>): void;
+    private onWorldEventRecord;
+    close(): void;
+    sendEvent(event: ISendEvent): void;
+    objects(): ObjectIterator<IObject>;
+    getObjectsByTable(table: string): ObjectIterator<IObject>;
+    getObjectByTable(table: string): IObject | null;
+}
+export {};

package/dist/index.js

@@ -0,0 +1,204 @@
+export class SpawnEvent extends Event {
+    object;
+    constructor(object) {
+        super("spawn");
+        this.object = object;
+    }
+}
+export class DespawnEvent extends Event {
+    object;
+    constructor(object) {
+        super("despawn");
+        this.object = object;
+    }
+}
+export class ChangeEvent extends Event {
+    object;
+    changes;
+    constructor(object, changes) {
+        super("change");
+        this.object = object;
+        this.changes = changes;
+    }
+}
+export function getDeviceId() {
+    let id = localStorage.getItem('device-id');
+    if (!id) {
+        id = crypto.randomUUID();
+        localStorage.setItem('device-id', id);
+    }
+    return id;
+}
+export class Client extends EventTarget {
+    url;
+    _window = null;
+    _socket = null;
+    _isConnected = false;
+    _objects = new Map();
+    constructor(url = "ws://127.0.0.1:3411/ws") {
+        super();
+        this.url = url;
+        let w = window;
+        while (w.GRAPHOS_WORLD_PLUGIN_CLIENT_VERSION === undefined) {
+            if (w.parent && w.parent !== w) {
+                w = w.parent;
+            }
+            else {
+                w = null;
+                break;
+            }
+        }
+        this._window = w;
+        if (w) {
+            w.addEventListener('world-event-record-clear', this.onWorldEventRecordClear.bind(this));
+            w.addEventListener('world-event-record', this.onWorldEventRecord.bind(this));
+        }
+        else {
+            this.onSocketConnect();
+        }
+    }
+    onSocketConnect() {
+        if (this._socket) {
+            this._socket.close();
+            this._socket = null;
+        }
+        this._socket = new WebSocket(this.url);
+        console.log('Connecting to WebSocket...');
+        this._socket.onmessage = (e) => {
+            let envelope = null;
+            try {
+                envelope = JSON.parse(e.data);
+            }
+            catch {
+                envelope = null;
+            }
+            if (!envelope)
+                return;
+            if (envelope.type === 'world-event-record') {
+                let record = envelope.payload;
+                this.onWorldEventRecord(new CustomEvent('world-event-record', { detail: record }));
+            }
+            else if (envelope.type === 'world-event-record-clear') {
+                this.onWorldEventRecordClear();
+            }
+        };
+        this._socket.onopen = () => {
+            console.log('WebSocket connected');
+            this._isConnected = true;
+            let envelope = {
+                type: 'world-device',
+                payload: {
+                    id: getDeviceId(),
+                    type: 'cocos',
+                    platform: "web",
+                    language: navigator.language,
+                    os: navigator.platform,
+                    osVersion: navigator.userAgent,
+                },
+            };
+            this._socket.send(JSON.stringify(envelope));
+            console.log('WebSocket connected');
+        };
+        this._socket.onclose = () => {
+            this._isConnected = false;
+            console.log('WebSocket disconnected');
+            setTimeout(() => { this.onSocketConnect(); }, 3000);
+        };
+    }
+    onWorldEventRecordClear() {
+        this._objects.clear();
+    }
+    onDataBindingChange(object, v) {
+    }
+    onWorldEventRecord(e) {
+        let record = e.detail;
+        if (record.type === 'get' || record.type === 'add') {
+            let v = record.data;
+            let vs = this._objects.get(v.table);
+            if (!vs) {
+                vs = new Map();
+                this._objects.set(v.table, vs);
+            }
+            let old = vs.get(v.id);
+            if (old) {
+                this.dispatchEvent(new DespawnEvent(old));
+            }
+            vs.set(v.id, v);
+            this.dispatchEvent(new SpawnEvent(v));
+        }
+        else if (record.type === 'set') {
+            let v = record.data;
+            let vs = this._objects.get(v.table);
+            if (!vs)
+                return;
+            let old = vs.get(v.id);
+            if (!old)
+                return;
+            Object.assign(old, v);
+            this.dispatchEvent(new ChangeEvent(old, v));
+        }
+        else if (record.type === 'del') {
+            let v = record.data;
+            let vs = this._objects.get(v.table);
+            if (!vs)
+                return;
+            let old = vs.get(v.id);
+            if (!old)
+                return;
+            vs.delete(v.id);
+            this.dispatchEvent(new DespawnEvent(old));
+        }
+    }
+    close() {
+        if (this._window) {
+            this._window.removeEventListener('world-event-record-clear', this.onWorldEventRecordClear.bind(this));
+            this._window.removeEventListener('world-event-record', this.onWorldEventRecord.bind(this));
+        }
+        else if (this._socket) {
+            this._socket.close();
+            this._socket = null;
+        }
+    }
+    sendEvent(event) {
+        if (this._window) {
+            this._window.dispatchEvent(new CustomEvent('world-send-event', { detail: event }));
+        }
+        else if (this._isConnected && this._socket) {
+            let envelope = {
+                type: 'world-send-event',
+                payload: event,
+            };
+            this._socket.send(JSON.stringify(envelope));
+        }
+    }
+    objects() {
+        const self = this;
+        return (function* () {
+            for (const tableObjects of self._objects.values()) {
+                for (const object of tableObjects.values()) {
+                    yield object;
+                }
+            }
+        })();
+    }
+    getObjectsByTable(table) {
+        const self = this;
+        return (function* () {
+            const tableObjects = self._objects.get(table);
+            if (!tableObjects)
+                return;
+            for (const object of tableObjects.values()) {
+                yield object;
+            }
+        })();
+    }
+    getObjectByTable(table) {
+        const tableObjects = this._objects.get(table);
+        if (!tableObjects)
+            return null;
+        for (const object of tableObjects.values()) {
+            return object;
+        }
+        return null;
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,27 @@
+export interface IEventSource<T extends IObject> {
+    readonly object: T;
+    readonly id: string;
+    readonly table: string;
+}
+export interface IEvent<T extends IObject> {
+    readonly type: string;
+    readonly source: IEventSource<T>;
+}
+export interface ITable {
+    id: string;
+    name: string;
+    keys: string[];
+}
+export interface IObject {
+    table: string;
+    id: string;
+    [key: string]: any;
+}
+export interface ISendEvent {
+    readonly type: string;
+    [key: string]: any;
+}
+export interface Vec2 {
+    x: number;
+    y: number;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "graphos-world-client",
+  "version": "1.0.0",
+  "description": "",
+  "license": "ISC",
+  "author": "",
+  "type": "module",
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc"
+  },
+  "devDependencies": {
+    "@types/node": "^25.8.0",
+    "typescript": "^6.0.3"
+  },
+  "files": [
+    "dist/"
+  ]
+}