@phystack/hub-client 4.4.29

package/dist/index.js

@@ -0,0 +1,1013 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectPhyClient = exports.PhyHubClient = void 0;
+const twin_types_1 = require("./types/twin.types");
+const phyhub_connection_service_1 = require("./services/phyhub-connection.service");
+const signals_service_1 = require("./services/signals.service");
+const signal_types_1 = require("./types/signal.types");
+const datachannel_1 = require("./services/webrtc/datachannel");
+const mediastream_1 = require("./services/webrtc/mediastream");
+(async function initializeWebRTCGlobals() {
+    if (typeof window !== 'undefined')
+        return;
+    try {
+        const wrtc = require('@roamhq/wrtc');
+        if (typeof global.MediaStream === 'undefined' && wrtc.MediaStream) {
+            global.MediaStream = wrtc.MediaStream;
+            console.log('Global MediaStream initialized');
+        }
+        if (typeof global.RTCPeerConnection === 'undefined' && wrtc.RTCPeerConnection) {
+            global.RTCPeerConnection = wrtc.RTCPeerConnection;
+            console.log('Global RTCPeerConnection initialized');
+        }
+        if (typeof global.RTCSessionDescription === 'undefined' && wrtc.RTCSessionDescription) {
+            global.RTCSessionDescription = wrtc.RTCSessionDescription;
+            console.log('Global RTCSessionDescription initialized');
+        }
+        if (typeof global.RTCIceCandidate === 'undefined' && wrtc.RTCIceCandidate) {
+            global.RTCIceCandidate = wrtc.RTCIceCandidate;
+            console.log('Global RTCIceCandidate initialized');
+        }
+        if (typeof global.RTCVideoSource === 'undefined' && wrtc.nonstandard.RTCVideoSource) {
+            global.RTCVideoSource = wrtc.nonstandard.RTCVideoSource;
+            console.log('Global RTCVideoSource initialized');
+        }
+        console.log('WebRTC globals successfully initialized');
+    }
+    catch (error) {
+        console.error('Failed to initialize WebRTC globals:', error);
+    }
+})().catch(err => console.error('Error in WebRTC globals initialization:', err));
+class PhyHubClient {
+    constructor(params = {}) {
+        this.instanceId = undefined;
+        this.moduleName = undefined;
+        this.socket = null;
+        this.socketConnected = false;
+        this.emitQueue = [];
+        this.lastDeviceStatusCheck = 0;
+        this.lastDeviceStatusResponse = undefined;
+        this.subscribedTwins = new Set();
+        this.twinMessageListeners = {};
+        this.instances = new Map();
+        this.peripheralInstances = new Map();
+        this.twinUpdateListeners = {};
+        this.EVENTS = {
+            PING: 'ping',
+            PONG: 'pong',
+            CONNECT: 'connect',
+            RECONNECT: 'reconnect',
+            RECONNECT_ERROR: 'reconnect_error',
+            RECONNECT_FAILED: 'reconnect_failed',
+            DISCONNECT: 'disconnect',
+            REPORT_SCREEN_INSTANCE_PROPERTIES: 'setScreenInstanceReportedProperties',
+            GET_DEVICE_STATUS: 'getDeviceStatus',
+            GET_DEVICE_NETWORKS: 'getDeviceNetworks',
+            GET_DEVICE_INSTANCE: 'getDeviceInstance',
+            GET_INSTANCE: 'getInstance',
+            SIGNAL_EVENT: 'sendEventSignal',
+            SIGNAL_CHECKOUT: 'sendEventSignal',
+            SIGNAL_PURCHASE: 'sendEventSignal',
+            SIGNAL_SESSION: 'sendSessionSignal',
+            SIGNAL_CLIENT: 'sendClientSignal',
+            TWIN_MESSAGE: 'twinMessage',
+            TWIN_SUBSCRIBE: 'twinSubscribe',
+            TWIN_UNSUBSCRIBE: 'twinUnsubscribe',
+            GET_TWIN_BY_ID: 'getTwinById',
+        };
+        this.getSocket = () => {
+            return this.socket;
+        };
+        this.initializeSignals = async (initParams) => {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5;
+            let edgeTwin;
+            if (!initParams) {
+                await this.getDeviceStatus();
+                if (!this.lastDeviceStatusResponse) {
+                    throw new Error('Failed to fetch device settings');
+                }
+                edgeTwin = (await this.getInstance());
+                if (!edgeTwin) {
+                    throw new Error('Unable to determine app settings');
+                }
+            }
+            const initSignalsPayload = {
+                deviceId: (_d = (_b = (_a = initParams === null || initParams === void 0 ? void 0 : initParams.deviceId) !== null && _a !== void 0 ? _a : edgeTwin === null || edgeTwin === void 0 ? void 0 : edgeTwin.deviceId) !== null && _b !== void 0 ? _b : (_c = this.lastDeviceStatusResponse) === null || _c === void 0 ? void 0 : _c.deviceId) !== null && _d !== void 0 ? _d : '',
+                installationId: (_f = (_e = initParams === null || initParams === void 0 ? void 0 : initParams.installationId) !== null && _e !== void 0 ? _e : edgeTwin === null || edgeTwin === void 0 ? void 0 : edgeTwin.properties.desired.installationId) !== null && _f !== void 0 ? _f : '',
+                spaceId: (_j = (_g = initParams === null || initParams === void 0 ? void 0 : initParams.spaceId) !== null && _g !== void 0 ? _g : (_h = this.lastDeviceStatusResponse) === null || _h === void 0 ? void 0 : _h.spaceId) !== null && _j !== void 0 ? _j : '',
+                tenantId: (_m = (_k = initParams === null || initParams === void 0 ? void 0 : initParams.tenantId) !== null && _k !== void 0 ? _k : (_l = this.lastDeviceStatusResponse) === null || _l === void 0 ? void 0 : _l.tenantId) !== null && _m !== void 0 ? _m : '',
+                appVersion: (_o = initParams === null || initParams === void 0 ? void 0 : initParams.appVersion) !== null && _o !== void 0 ? _o : 'XXXXXXXXXXXXXXXXXXXXXXXX',
+                appId: (_p = initParams === null || initParams === void 0 ? void 0 : initParams.appId) !== null && _p !== void 0 ? _p : 'XXXXXXXXXXXXXXXXXXXXXXXX',
+                environment: (_s = (_q = initParams === null || initParams === void 0 ? void 0 : initParams.environment) !== null && _q !== void 0 ? _q : (_r = this.lastDeviceStatusResponse) === null || _r === void 0 ? void 0 : _r.gridEnv) !== null && _s !== void 0 ? _s : '',
+                dataResidency: ((_v = (_t = initParams === null || initParams === void 0 ? void 0 : initParams.dataResidency) !== null && _t !== void 0 ? _t : (_u = this.lastDeviceStatusResponse) === null || _u === void 0 ? void 0 : _u.dataResidency) !== null && _v !== void 0 ? _v : '').toUpperCase(),
+                country: (_w = initParams === null || initParams === void 0 ? void 0 : initParams.country) !== null && _w !== void 0 ? _w : 'SE',
+                installationVersion: (_x = initParams === null || initParams === void 0 ? void 0 : initParams.installationVersion) !== null && _x !== void 0 ? _x : 'XXXXXXXXXXXXXXXXXXXXXXXX',
+                accessToken: (_y = initParams === null || initParams === void 0 ? void 0 : initParams.accessToken) !== null && _y !== void 0 ? _y : (_z = this.lastDeviceStatusResponse) === null || _z === void 0 ? void 0 : _z.accessKey,
+                clientUserAgent: (_0 = initParams === null || initParams === void 0 ? void 0 : initParams.clientUserAgent) !== null && _0 !== void 0 ? _0 : undefined,
+                ip: (_5 = (_1 = initParams === null || initParams === void 0 ? void 0 : initParams.ip) !== null && _1 !== void 0 ? _1 : (_4 = (_3 = (_2 = this.lastDeviceStatusResponse) === null || _2 === void 0 ? void 0 : _2.ip) === null || _3 === void 0 ? void 0 : _3[0]) === null || _4 === void 0 ? void 0 : _4.ipv4) !== null && _5 !== void 0 ? _5 : 'N/A',
+            };
+            this.signals = new signals_service_1.SignalsService(this, initSignalsPayload);
+            return this.signals;
+        };
+        this.getDataChannel = async (targetTwinId) => {
+            const options = {
+                targetTwinId,
+                sendTwinMessage: this.sendTwinMessage.bind(this),
+                subscribeTwin: this.subscribeTwin.bind(this),
+                onTwinMessage: this.onTwinMessage.bind(this),
+                offTwinMessage: this.offTwinMessage.bind(this),
+                useStun: true,
+                isInitiator: true,
+                channelPrefix: 'channel',
+                mediaOptions: { isMediaConnection: false },
+            };
+            const result = (await (0, datachannel_1.createWebRTCDataChannelConnection)(options));
+            return result.dataChannel;
+        };
+        this.onDataChannel = async (sourceTwinId, callback) => {
+            const options = {
+                targetTwinId: sourceTwinId,
+                sendTwinMessage: this.sendTwinMessage.bind(this),
+                subscribeTwin: this.subscribeTwin.bind(this),
+                onTwinMessage: this.onTwinMessage.bind(this),
+                offTwinMessage: this.offTwinMessage.bind(this),
+                useStun: true,
+                isInitiator: false,
+                channelPrefix: 'channel',
+                mediaOptions: { isMediaConnection: false },
+            };
+            const result = (await (0, datachannel_1.createWebRTCDataChannelConnection)(options));
+            callback(result.dataChannel);
+        };
+        this.onMediaStream = async (sourceTwinId, callback) => {
+            const options = {
+                targetTwinId: sourceTwinId,
+                sendTwinMessage: this.sendTwinMessage.bind(this),
+                subscribeTwin: this.subscribeTwin.bind(this),
+                onTwinMessage: this.onTwinMessage.bind(this),
+                offTwinMessage: this.offTwinMessage.bind(this),
+                isInitiator: false,
+                channelPrefix: 'media',
+                mediaOptions: {
+                    isMediaConnection: true,
+                },
+            };
+            const result = await (0, mediastream_1.createWebRTCMediaStreamConnection)(options);
+            callback(result.mediaStream);
+        };
+        this.instanceId = params.instanceId;
+        if (!this.instanceId) {
+            if (typeof window !== 'undefined') {
+                console.log('Running in browser, looking for instanceId in URL hash', window.location.hash);
+                this.instanceId =
+                    new URLSearchParams(window.location.hash.slice(1)).get('instanceId') || undefined;
+                console.log('Found instanceId in URL hash', this.instanceId);
+            }
+            else {
+                this.instanceId = process.env.TWIN_ID;
+            }
+        }
+        this.moduleName = params.moduleName;
+    }
+    async initializeConnection() {
+        if (this.socket && this.socketConnected) {
+            return this;
+        }
+        try {
+            console.log('initializeConnection()', JSON.stringify({
+                instanceId: this.instanceId,
+                moduleName: this.moduleName,
+            }, null, 2));
+            const phyHubConnection = phyhub_connection_service_1.PhyHubConnection.getInstance({
+                instanceId: this.instanceId,
+                moduleName: this.moduleName,
+            });
+            this.socket = await phyHubConnection.getPhyHubSocket();
+            await new Promise((resolve, reject) => {
+                var _a, _b, _c;
+                if ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.connected) {
+                    this.socketConnected = true;
+                    resolve();
+                }
+                else {
+                    (_b = this.socket) === null || _b === void 0 ? void 0 : _b.once('connect', () => {
+                        this.socketConnected = true;
+                        resolve();
+                    });
+                    (_c = this.socket) === null || _c === void 0 ? void 0 : _c.once('connect_error', error => {
+                        reject(error);
+                    });
+                }
+            });
+            this.setupSocketListeners((value) => value, (reason) => {
+                throw reason;
+            });
+            return this;
+        }
+        catch (err) {
+            this.socket = null;
+            this.socketConnected = false;
+            throw err;
+        }
+    }
+    setupSocketListeners(resolve, _reject) {
+        if (!this.socket)
+            return;
+        this.socket.on(this.EVENTS.PONG, (data) => {
+            setTimeout(() => {
+                this.emit('ping', { count: data.data.count + 1 });
+            }, 30000);
+        });
+        this.socket.on(this.EVENTS.CONNECT, () => {
+            this.socketConnected = true;
+            this.emit(this.EVENTS.PING, { count: 1 });
+            this.processEmitQueue();
+            this.subscribedTwins.forEach(twinId => {
+                this.subscribeTwin(twinId).catch(error => {
+                    console.error(`Failed to re-subscribe to twin ${twinId}:`, error);
+                });
+            });
+            resolve(this);
+        });
+        this.socket.io.on(this.EVENTS.RECONNECT, () => {
+            this.socketConnected = true;
+            this.processEmitQueue();
+            this.subscribedTwins.forEach(twinId => {
+                this.subscribeTwin(twinId).catch(error => {
+                    console.error(`Failed to re-subscribe to twin ${twinId}:`, error);
+                });
+            });
+        });
+        this.socket.io.on(this.EVENTS.RECONNECT_ERROR, () => {
+            this.socketConnected = false;
+        });
+        this.socket.io.on(this.EVENTS.RECONNECT_FAILED, () => {
+            this.socketConnected = false;
+        });
+        this.socket.on(this.EVENTS.DISCONNECT, () => {
+            this.socketConnected = false;
+        });
+        this.socket.on(this.EVENTS.TWIN_MESSAGE, (payload) => {
+            if (payload.twinId && payload.data) {
+                const listeners = this.twinMessageListeners[payload.twinId];
+                if (listeners) {
+                    listeners.forEach(callback => {
+                        try {
+                            callback(payload);
+                        }
+                        catch (error) {
+                            console.error(`Error in twin message listener for ${payload.twinId}:`, error);
+                        }
+                    });
+                }
+                else {
+                }
+            }
+            else {
+            }
+        });
+        this.socket.on('twinUpdated', (payload) => {
+            console.log('twinUpdated event received', JSON.stringify(payload, null, 2));
+            if (payload.data) {
+                const twinId = payload.twinId || payload.data.id;
+                if (twinId && this.twinUpdateListeners[twinId]) {
+                    this.twinUpdateListeners[twinId].forEach(cb => {
+                        try {
+                            cb(payload.data);
+                            console.log('twinUpdateListeners[twinId].forEach() callback executed', JSON.stringify(payload.data, null, 2));
+                        }
+                        catch (error) {
+                            console.error(`Error in twin update listener for ${twinId}:`, error);
+                        }
+                    });
+                }
+            }
+        });
+    }
+    async assureSocketConnection() {
+        if (!this.socket || !this.socketConnected) {
+            await this.initializeConnection();
+        }
+        if (!this.socket) {
+            throw new Error('Socket not initialized');
+        }
+    }
+    static async connect(params = {}) {
+        console.info(`connect(): Connecting to phyhub`);
+        if (!PhyHubClient.instance) {
+            PhyHubClient.instance = new PhyHubClient(params);
+            await PhyHubClient.instance.initializeConnection();
+            console.info(`connect(): Connection to phyhub initialized`);
+        }
+        return PhyHubClient.instance;
+    }
+    isConnected() {
+        return this.socketConnected;
+    }
+    async sendSignal(type, data) {
+        let eventToEmit = undefined;
+        switch (type) {
+            case signal_types_1.DataRequestTypeEnum.EVENT:
+                eventToEmit = this.EVENTS.SIGNAL_EVENT;
+                break;
+            case signal_types_1.DataRequestTypeEnum.CHECKOUT:
+                eventToEmit = this.EVENTS.SIGNAL_CHECKOUT;
+                break;
+            case signal_types_1.DataRequestTypeEnum.PURCHASE:
+                eventToEmit = this.EVENTS.SIGNAL_PURCHASE;
+                break;
+            case signal_types_1.DataRequestTypeEnum.SESSION:
+                eventToEmit = this.EVENTS.SIGNAL_SESSION;
+                break;
+            case signal_types_1.DataRequestTypeEnum.CLIENT:
+                eventToEmit = this.EVENTS.SIGNAL_CLIENT;
+                break;
+            default:
+                throw new Error(`Unsupported type ${type}`);
+        }
+        if (!eventToEmit) {
+            throw new Error(`Unsupported type ${type}`);
+        }
+        const payload = {
+            data,
+        };
+        this.emit(eventToEmit, payload);
+    }
+    async getDeviceStatus() {
+        await this.assureSocketConnection();
+        const now = Date.now();
+        const tenSeconds = 10 * 1000;
+        if (now - this.lastDeviceStatusCheck < tenSeconds) {
+            return Promise.resolve(this.lastDeviceStatusResponse);
+        }
+        return new Promise((resolve, reject) => {
+            var _a;
+            this.lastDeviceStatusCheck = now;
+            this.emit(this.EVENTS.GET_DEVICE_STATUS, (response) => {
+                this.lastDeviceStatusResponse = response;
+                resolve(response);
+            });
+            (_a = this.socket) === null || _a === void 0 ? void 0 : _a.on('error', (error) => {
+                reject(error);
+            });
+        });
+    }
+    async getMediaStream(targetTwinId) {
+        const options = {
+            targetTwinId,
+            sendTwinMessage: this.sendTwinMessage.bind(this),
+            subscribeTwin: this.subscribeTwin.bind(this),
+            onTwinMessage: this.onTwinMessage.bind(this),
+            offTwinMessage: this.offTwinMessage.bind(this),
+            isInitiator: true,
+            channelPrefix: 'media',
+            mediaOptions: {
+                isMediaConnection: true,
+                mediaDirection: 'recvonly',
+            },
+        };
+        const result = await (0, mediastream_1.createWebRTCMediaStreamConnection)(options);
+        return {
+            stream: result.mediaStream,
+            close: result.close,
+        };
+    }
+    async getInstance() {
+        if (!this.instanceId) {
+            throw new Error('Instance ID not set');
+        }
+        if (this.instances.has(this.instanceId)) {
+            return this.instances.get(this.instanceId);
+        }
+        await this.assureSocketConnection();
+        let instance;
+        let instanceTwin = await this.getTwinById(this.instanceId);
+        const edgeInstanceTypePrefix = 'edgeInstance';
+        const edgeTwinEmit = (type, payload) => {
+            const { id: twinId } = instanceTwin;
+            const edgeTwinMessagePayload = {
+                type: `${edgeInstanceTypePrefix}:${type}`,
+                sourceTwinId: twinId,
+                sourceDeviceId: instanceTwin.deviceId,
+                data: payload,
+            };
+            this.sendTwinMessage(twinId, edgeTwinMessagePayload);
+        };
+        const edgeTwinOn = (type, callback) => {
+            const { id: twinId } = instanceTwin;
+            const onEdgeTwinMessage = (payload) => {
+                var _a, _b;
+                const messageType = ((_a = payload.data) === null || _a === void 0 ? void 0 : _a.type) || payload.type;
+                if (messageType === `${edgeInstanceTypePrefix}:${type}`) {
+                    callback(((_b = payload.data) === null || _b === void 0 ? void 0 : _b.data) || payload.data);
+                }
+                else {
+                }
+            };
+            this.onTwinMessage(twinId, onEdgeTwinMessage);
+        };
+        const edgeTwinTo = (targetTwinId) => ({
+            emit: (type, payload) => {
+                const edgeTwinMessagePayload = {
+                    type: `${edgeInstanceTypePrefix}:${type}`,
+                    sourceTwinId: instanceTwin.id,
+                    sourceDeviceId: instanceTwin.deviceId,
+                    data: payload,
+                };
+                this.sendTwinMessage(targetTwinId, edgeTwinMessagePayload);
+            },
+        });
+        const getPeripheralTwins = async () => {
+            const payload = {
+                data: {
+                    instanceId: instanceTwin.id,
+                },
+            };
+            return new Promise((resolve, reject) => {
+                var _a;
+                this.emit('getPeripheralTwins', payload, (response) => {
+                    const { twins } = response;
+                    resolve(twins || []);
+                });
+                (_a = this.socket) === null || _a === void 0 ? void 0 : _a.on('error', (error) => {
+                    reject(error);
+                });
+            });
+        };
+        const createPeripheralTwin = async (peripheralName, hardwareId, desiredProperties, descriptors) => {
+            const existingTwins = (await getPeripheralTwins());
+            const existingTwin = existingTwins.find((twin) => twin.properties.desired.hardwareId === hardwareId);
+            if (existingTwin) {
+                throw new Error(`Peripheral twin with hardwareId ${hardwareId} already exists`);
+            }
+            const payload = {
+                data: {
+                    deviceId: instanceTwin.deviceId,
+                    tenantId: instanceTwin.tenantId,
+                    instanceId: instanceTwin.id,
+                    peripheralName,
+                    hardwareId,
+                    desiredProperties,
+                    descriptors,
+                },
+            };
+            return new Promise((resolve, reject) => {
+                var _a;
+                this.emit('createPeripheralTwin', payload, (response) => {
+                    const { twin } = response;
+                    if (!twin)
+                        throw new Error('Failed to create peripheral twin');
+                    resolve(twin);
+                });
+                (_a = this.socket) === null || _a === void 0 ? void 0 : _a.on('error', (error) => {
+                    reject(error);
+                });
+            });
+        };
+        const getDataChannel = async () => {
+            return await this.getDataChannel(instanceTwin.id);
+        };
+        const onDataChannel = async (callback) => {
+            return await this.onDataChannel(instanceTwin.id, callback);
+        };
+        const getMediaStream = async () => {
+            if (!instance) {
+                throw new Error('Instance not initialized');
+            }
+            return await this.getMediaStream(instance.id);
+        };
+        const onMediaStream = async (callback) => {
+            if (!instance) {
+                throw new Error('Instance not initialized');
+            }
+            await this.onMediaStream(instance.id, callback);
+        };
+        const updateReported = async (properties) => {
+            const newReported = {
+                ...properties,
+            };
+            const result = await this.updateReportedProperties(instanceTwin.id, newReported);
+            Object.assign(instance, result);
+            return result;
+        };
+        instance = {
+            ...instanceTwin,
+            emit: edgeTwinEmit,
+            on: edgeTwinOn,
+            to: edgeTwinTo,
+            createPeripheralTwin,
+            updateReported,
+            getPeripheralTwins,
+            getDataChannel,
+            onDataChannel,
+            getMediaStream,
+            onMediaStream,
+        };
+        this.instances.set(this.instanceId, instance);
+        return instance;
+    }
+    async getEdgeInstance() {
+        return this.getInstance();
+    }
+    async getScreenInstance() {
+        return this.getInstance();
+    }
+    async getPeripheralInstance(peripheralTwinId) {
+        if (this.peripheralInstances.has(peripheralTwinId)) {
+            return this.peripheralInstances.get(peripheralTwinId);
+        }
+        let peripheralInstance;
+        const edgeInstance = await this.getInstance();
+        if (!edgeInstance) {
+            console.error('Edge instance not found');
+            throw new Error('Edge instance not found');
+        }
+        const peripheralTwin = await this.getTwinById(peripheralTwinId);
+        if (!peripheralTwin) {
+            console.error(`Peripheral twin with id ${peripheralTwinId} not found`);
+            throw new Error(`Peripheral twin with id ${peripheralTwinId} not found`);
+        }
+        if (peripheralTwin.type !== twin_types_1.TwinTypeEnum.Peripheral) {
+            throw new Error(`Twin ${peripheralTwinId} is not a peripheral twin`);
+        }
+        await this.subscribeTwin(peripheralTwinId);
+        const instanceTypePrefix = 'peripheralInstance';
+        const peripheralTwinEmit = (type, payload) => {
+            const messagePayload = {
+                type: `${instanceTypePrefix}:${peripheralTwin.id}:${type}`,
+                sourceTwinId: peripheralTwin.id,
+                sourceDeviceId: edgeInstance.deviceId,
+                data: payload,
+            };
+            this.sendTwinMessage(peripheralTwin.id, messagePayload);
+        };
+        const peripheralTwinOn = (type, callback) => {
+            console.log(`Setting up listener for peripheral ${peripheralTwinId} event: ${type}`);
+            const onMessage = (payload) => {
+                var _a, _b;
+                const messageType = ((_a = payload.data) === null || _a === void 0 ? void 0 : _a.type) || payload.type;
+                if (messageType === `${instanceTypePrefix}:${peripheralTwin.id}:${type}`) {
+                    callback(((_b = payload.data) === null || _b === void 0 ? void 0 : _b.data) || payload.data);
+                }
+                else {
+                }
+            };
+            this.onTwinMessage(peripheralTwin.id, onMessage);
+        };
+        const peripheralTwinTo = (targetTwinId) => ({
+            emit: (type, payload) => {
+                const messagePayload = {
+                    type: `${instanceTypePrefix}:${peripheralTwin.id}:${type}`,
+                    sourceTwinId: edgeInstance.id,
+                    sourceDeviceId: edgeInstance.deviceId,
+                    data: payload,
+                };
+                this.sendTwinMessage(targetTwinId, messagePayload);
+            },
+        });
+        const getDataChannel = async () => {
+            return await this.getDataChannel(peripheralTwin.id);
+        };
+        const onDataChannel = async (callback) => {
+            return await this.onDataChannel(peripheralTwin.id, callback);
+        };
+        const getMediaStream = async () => {
+            if (!peripheralInstance) {
+                throw new Error('Peripheral instance not initialized');
+            }
+            return await this.getMediaStream(peripheralInstance.id);
+        };
+        const onMediaStream = async (callback) => {
+            if (!peripheralInstance) {
+                throw new Error('Peripheral instance not initialized');
+            }
+            await this.onMediaStream(peripheralInstance.id, callback);
+        };
+        const updateReported = async (properties) => {
+            const newReported = {
+                ...properties,
+            };
+            const result = await this.updateReportedProperties(peripheralTwin.id, newReported);
+            Object.assign(peripheralInstance, result);
+            return result;
+        };
+        const onUpdateReported = (callback) => {
+            let previousProperties = undefined;
+            console.log(`[onUpdateReported] Registering handler for all reported properties`);
+            this.onTwinUpdate(peripheralTwin.id, (twin) => {
+                console.log(`[onUpdateReported] Twin update received for ${peripheralTwin.id}`);
+                if (twin.id !== peripheralTwin.id) {
+                    console.log(`[onUpdateReported] Twin ID mismatch: ${twin.id} !== ${peripheralTwin.id}`);
+                    return;
+                }
+                const reported = twin.properties.reported;
+                if (reported) {
+                    if (previousProperties === undefined) {
+                        console.log(`[onUpdateReported] First update - calling callback`);
+                        previousProperties = JSON.parse(JSON.stringify(reported));
+                        callback(reported);
+                        return;
+                    }
+                    const currentPropertiesStr = JSON.stringify(reported);
+                    const previousPropertiesStr = JSON.stringify(previousProperties);
+                    console.log(`[onUpdateReported] Current (end): ...${currentPropertiesStr.substring(currentPropertiesStr.length - 100)}`);
+                    console.log(`[onUpdateReported] Previous (end): ...${previousPropertiesStr.substring(previousPropertiesStr.length - 100)}`);
+                    if (currentPropertiesStr.length !== previousPropertiesStr.length) {
+                        console.log(`[onUpdateReported] String length changed: ${currentPropertiesStr.length} vs ${previousPropertiesStr.length}`);
+                    }
+                    const hasChanged = currentPropertiesStr !== previousPropertiesStr;
+                    console.log(`[onUpdateReported] Properties comparison:`, hasChanged ? 'CHANGED' : 'UNCHANGED');
+                    if (hasChanged) {
+                        previousProperties = JSON.parse(currentPropertiesStr);
+                        console.log(`[onUpdateReported] Calling callback with updated reported properties`);
+                        callback(reported);
+                    }
+                    else {
+                        console.log(`[onUpdateReported] No change detected in properties`);
+                    }
+                }
+                else {
+                    console.log(`[onUpdateReported] No reported properties found`);
+                }
+            });
+        };
+        const onUpdateDesired = (callback) => {
+            let previousProperties = undefined;
+            console.log(`[onUpdateDesired] Registering handler for all desired properties`);
+            this.onTwinUpdate(peripheralTwin.id, (twin) => {
+                console.log(`[onUpdateDesired] Twin update received for ${peripheralTwin.id}`);
+                if (twin.id !== peripheralTwin.id) {
+                    console.log(`[onUpdateDesired] Twin ID mismatch: ${twin.id} !== ${peripheralTwin.id}`);
+                    return;
+                }
+                const desired = twin.properties.desired;
+                if (desired) {
+                    if (previousProperties === undefined) {
+                        console.log(`[onUpdateDesired] First update - calling callback`);
+                        previousProperties = JSON.parse(JSON.stringify(desired));
+                        callback(desired);
+                        return;
+                    }
+                    const currentPropertiesStr = JSON.stringify(desired);
+                    const previousPropertiesStr = JSON.stringify(previousProperties);
+                    console.log(`[onUpdateDesired] Current (end): ...${currentPropertiesStr.substring(currentPropertiesStr.length - 100)}`);
+                    console.log(`[onUpdateDesired] Previous (end): ...${previousPropertiesStr.substring(previousPropertiesStr.length - 100)}`);
+                    if (currentPropertiesStr.length !== previousPropertiesStr.length) {
+                        console.log(`[onUpdateDesired] String length changed: ${currentPropertiesStr.length} vs ${previousPropertiesStr.length}`);
+                    }
+                    const hasChanged = currentPropertiesStr !== previousPropertiesStr;
+                    console.log(`[onUpdateDesired] Properties comparison:`, hasChanged ? 'CHANGED' : 'UNCHANGED');
+                    if (hasChanged) {
+                        previousProperties = JSON.parse(currentPropertiesStr);
+                        console.log(`[onUpdateDesired] Calling callback with updated desired properties`);
+                        callback(desired);
+                    }
+                    else {
+                        console.log(`[onUpdateDesired] No change detected in properties`);
+                    }
+                }
+                else {
+                    console.log(`[onUpdateDesired] No desired properties found`);
+                }
+            });
+        };
+        const remove = async () => {
+            const payload = {
+                data: { twinId: peripheralTwin.id },
+            };
+            return new Promise((resolve, reject) => {
+                var _a;
+                this.emit('deletePeripheralTwin', payload, (response) => {
+                    const { twin } = response;
+                    resolve(twin);
+                });
+                (_a = this.socket) === null || _a === void 0 ? void 0 : _a.on('error', (error) => {
+                    reject(error);
+                });
+            });
+        };
+        const updateDesired = async (properties) => {
+            const payload = {
+                twinId: peripheralTwin.id,
+                data: properties,
+            };
+            return new Promise((resolve, reject) => {
+                var _a;
+                this.emit('updatePeripheralTwinDesired', payload, (response) => {
+                    const { twin } = response;
+                    resolve(twin || {});
+                });
+                (_a = this.socket) === null || _a === void 0 ? void 0 : _a.on('error', (error) => {
+                    reject(error);
+                });
+            });
+        };
+        peripheralInstance = {
+            ...peripheralTwin,
+            emit: peripheralTwinEmit,
+            on: peripheralTwinOn,
+            to: peripheralTwinTo,
+            updateReported,
+            updateDesired,
+            onUpdateReported,
+            onUpdateDesired,
+            remove,
+            getDataChannel,
+            onDataChannel,
+            getMediaStream,
+            onMediaStream,
+        };
+        this.peripheralInstances.set(peripheralTwinId, peripheralInstance);
+        return peripheralInstance;
+    }
+    getGridApp() {
+        let currentWindow = window;
+        while (currentWindow) {
+            try {
+                if (currentWindow.gridapp &&
+                    typeof currentWindow.gridapp.getSettings === 'function') {
+                    return currentWindow.gridapp;
+                }
+                if (currentWindow.parent === currentWindow)
+                    break;
+                currentWindow = currentWindow.parent;
+            }
+            catch (e) {
+                break;
+            }
+        }
+        return null;
+    }
+    async getSettings() {
+        if (typeof window !== 'undefined') {
+            const gridapp = this.getGridApp();
+            if (gridapp) {
+                return gridapp.getSettings();
+            }
+        }
+        const edgeInstance = await this.getInstance();
+        if (!edgeInstance) {
+            throw new Error('Edge instance not found');
+        }
+        return edgeInstance.properties.desired.settings;
+    }
+    async getEdgeSettings() {
+        return this.getSettings();
+    }
+    async getScreenSettings() {
+        return this.getSettings();
+    }
+    async getDeviceInstance() {
+        await this.assureSocketConnection();
+        return new Promise((resolve, reject) => {
+            var _a;
+            this.emit(this.EVENTS.GET_DEVICE_INSTANCE, (response) => {
+                resolve(response);
+            });
+            (_a = this.socket) === null || _a === void 0 ? void 0 : _a.on('error', (error) => {
+                reject(error);
+            });
+        });
+    }
+    async getDeviceNetworks() {
+        await this.assureSocketConnection();
+        return new Promise((resolve, reject) => {
+            var _a;
+            this.emit(this.EVENTS.GET_DEVICE_NETWORKS, (response) => {
+                resolve(response);
+            });
+            (_a = this.socket) === null || _a === void 0 ? void 0 : _a.on('error', (error) => {
+                reject(error);
+            });
+        });
+    }
+    async setScreenInstanceReportedProperties(payload) {
+        await this.assureSocketConnection();
+        console.info(`setScreenInstanceReportedProperties(): payload ${JSON.stringify(payload)}`);
+        return new Promise((resolve, reject) => {
+            var _a;
+            this.emit(this.EVENTS.REPORT_SCREEN_INSTANCE_PROPERTIES, payload, (response) => {
+                resolve(response);
+            });
+            (_a = this.socket) === null || _a === void 0 ? void 0 : _a.on('error', (error) => {
+                reject(error);
+            });
+        });
+    }
+    emit(method, ...args) {
+        if (!this.socket) {
+            console.error('emit(): Socket not created');
+            return;
+        }
+        const event = this.instanceId;
+        const callback = typeof args[args.length - 1] === 'function' ? args.pop() : undefined;
+        const payload = { method, ...args[0] };
+        const emitArgs = [event, payload];
+        if (callback) {
+            emitArgs.push(callback);
+        }
+        if (!this.socketConnected) {
+            console.info('emit(): Socket not connected, adding to emitQueue', emitArgs);
+            this.emitQueue.push(emitArgs);
+            return;
+        }
+        this.socket.emit(...emitArgs);
+    }
+    processEmitQueue() {
+        if (!this.socket || !this.socketConnected) {
+            return;
+        }
+        while (this.emitQueue.length > 0) {
+            const args = this.emitQueue.shift();
+            if (args) {
+                this.socket.emit.apply(this.socket, args);
+            }
+        }
+    }
+    onTwinUpdate(targetTwinId, callback) {
+        console.log(`onTwinUpdate() called for twin ${targetTwinId}`);
+        this.assureSocketConnection();
+        if (!this.twinUpdateListeners[targetTwinId]) {
+            this.twinUpdateListeners[targetTwinId] = new Set();
+        }
+        this.twinUpdateListeners[targetTwinId].add(callback);
+        console.log(`Added twin update listener for ${targetTwinId}. Total listeners: ${this.twinUpdateListeners[targetTwinId].size}`);
+        if (!this.subscribedTwins.has(targetTwinId)) {
+            this.subscribeTwin(targetTwinId).catch(error => {
+                console.error(`Failed to subscribe to twin ${targetTwinId} for updates:`, error);
+            });
+        }
+    }
+    offTwinUpdate(targetTwinId, callback) {
+        console.log(`Removing update listener for twin ${targetTwinId}`);
+        if (!this.twinUpdateListeners[targetTwinId]) {
+            console.log(`No update listeners found for twin ${targetTwinId}`);
+            return false;
+        }
+        const result = this.twinUpdateListeners[targetTwinId].delete(callback);
+        if (this.twinUpdateListeners[targetTwinId].size === 0) {
+            delete this.twinUpdateListeners[targetTwinId];
+            console.log(`Removed last update listener for twin ${targetTwinId}, cleaning up`);
+        }
+        else {
+            console.log(`Removed update listener. Remaining listeners: ${this.twinUpdateListeners[targetTwinId].size}`);
+        }
+        return result;
+    }
+    async sendTwinMessage(targetTwinId, data, callback) {
+        const edgeInstance = await this.getInstance();
+        if (!edgeInstance) {
+            console.error('sendTwinMessage failed: Edge instance not found');
+            throw new Error('Edge instance not found');
+        }
+        const { id: edgeTwinId, deviceId } = edgeInstance;
+        if (!deviceId) {
+            console.error('sendTwinMessage failed: Device ID not available');
+            throw new Error('Device ID not available - ensure device is connected');
+        }
+        const payload = {
+            twinId: targetTwinId,
+            sourceTwinId: edgeTwinId,
+            sourceDeviceId: deviceId,
+            data,
+        };
+        if (callback) {
+            this.emit(this.EVENTS.TWIN_MESSAGE, payload, (response) => {
+                callback(response);
+            });
+        }
+        else {
+            return new Promise((resolve, reject) => {
+                var _a;
+                this.emit(this.EVENTS.TWIN_MESSAGE, payload, (response) => {
+                    resolve(response);
+                });
+                (_a = this.socket) === null || _a === void 0 ? void 0 : _a.on('error', (error) => {
+                    console.error('sendTwinMessage socket error:', error);
+                    reject(error);
+                });
+            });
+        }
+    }
+    async onTwinMessage(targetTwinId, callback) {
+        var _a;
+        console.log('onTwinMessage called for twin:', {
+            targetTwinId,
+            existingListeners: ((_a = this.twinMessageListeners[targetTwinId]) === null || _a === void 0 ? void 0 : _a.size) || 0,
+        });
+        if (!this.twinMessageListeners[targetTwinId]) {
+            this.twinMessageListeners[targetTwinId] = new Set();
+        }
+        this.twinMessageListeners[targetTwinId].add(callback);
+        console.log(`Added new callback. Total listeners: ${this.twinMessageListeners[targetTwinId].size}`);
+        this.twinMessageListeners[targetTwinId].add(callback);
+    }
+    offTwinMessage(targetTwinId, callback) {
+        console.log(`Removing message listener for twin ${targetTwinId}`);
+        if (!this.twinMessageListeners[targetTwinId]) {
+            console.log(`No listeners found for twin ${targetTwinId}`);
+            return false;
+        }
+        const result = this.twinMessageListeners[targetTwinId].delete(callback);
+        if (this.twinMessageListeners[targetTwinId].size === 0) {
+            delete this.twinMessageListeners[targetTwinId];
+            console.log(`Removed last listener for twin ${targetTwinId}, cleaning up`);
+        }
+        else {
+            console.log(`Removed listener. Remaining listeners: ${this.twinMessageListeners[targetTwinId].size}`);
+        }
+        return result;
+    }
+    removeMessageListener(twinId, callback) {
+        const listeners = this.twinMessageListeners[twinId];
+        if (listeners) {
+            listeners.delete(callback);
+            if (listeners.size === 0) {
+                delete this.twinMessageListeners[twinId];
+            }
+        }
+    }
+    async subscribeTwin(targetTwinId, callback) {
+        console.log(`[subscribeTwin] Starting subscription to twin ${targetTwinId}`);
+        console.log(`[subscribeTwin] Current subscribed twins:`, Array.from(this.subscribedTwins));
+        console.log(`[subscribeTwin] Current listeners:`, Object.keys(this.twinMessageListeners));
+        this.subscribedTwins.add(targetTwinId);
+        const edgeInstance = await this.getInstance();
+        if (!edgeInstance) {
+            throw new Error('Edge instance not found');
+        }
+        const { id: edgeTwinId, deviceId } = edgeInstance;
+        const payload = {
+            twinId: targetTwinId,
+            sourceTwinId: edgeTwinId,
+            sourceDeviceId: deviceId,
+        };
+        console.log(`[subscribeTwin] Emitting TWIN_SUBSCRIBE with payload:`, payload);
+        if (callback) {
+            this.emit(this.EVENTS.TWIN_SUBSCRIBE, payload, (response) => {
+                console.log(`[subscribeTwin] Subscription callback response:`, response);
+                callback(response);
+            });
+        }
+        else {
+            return new Promise((resolve, reject) => {
+                var _a;
+                this.emit(this.EVENTS.TWIN_SUBSCRIBE, payload, (response) => {
+                    console.log(`[subscribeTwin] Subscription promise response:`, response);
+                    resolve(response);
+                });
+                (_a = this.socket) === null || _a === void 0 ? void 0 : _a.on('error', (error) => {
+                    console.error(`[subscribeTwin] Socket error:`, error);
+                    reject(error);
+                });
+            });
+        }
+    }
+    async getTwinById(twinId) {
+        const payload = {
+            data: { twinId },
+        };
+        return new Promise((resolve, reject) => {
+            var _a;
+            this.emit(this.EVENTS.GET_TWIN_BY_ID, payload, (response) => {
+                const { twin } = response;
+                if (!twin) {
+                    reject(new Error(`Twin with id ${twinId} not found`));
+                    return;
+                }
+                resolve(twin);
+            });
+            (_a = this.socket) === null || _a === void 0 ? void 0 : _a.on('error', (error) => {
+                reject(error);
+            });
+        });
+    }
+    async updateReportedProperties(twinId, reportedProperties) {
+        const payload = {
+            twinId,
+            data: reportedProperties,
+        };
+        return new Promise((resolve, reject) => {
+            var _a;
+            this.emit('reportPeripheralTwinProperties', payload, (response) => {
+                const { twin } = response;
+                if (!twin) {
+                    reject(new Error(`Failed to update reported properties for twin ${twinId}`));
+                    return;
+                }
+                resolve(twin);
+            });
+            (_a = this.socket) === null || _a === void 0 ? void 0 : _a.on('error', (error) => {
+                reject(error);
+            });
+        });
+    }
+}
+exports.PhyHubClient = PhyHubClient;
+PhyHubClient.instance = null;
+const connectPhyClient = (params = {}) => PhyHubClient.connect(params);
+exports.connectPhyClient = connectPhyClient;
+exports.default = {
+    connectPhyClient: exports.connectPhyClient,
+};
+//# sourceMappingURL=index.js.map