inhumate-rti 0.0.26

package/lib/rticlient.js

@@ -0,0 +1,775 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+import { EventEmitter } from "events";
+import { AGClientSocket } from "socketcluster-client";
+import { v4 as uuidv4 } from "uuid";
+import * as base64 from "base64-js";
+import constants, { channel as RTIchannel } from "./constants.js";
+import { Clients, Client, ParticipantRegistration } from "./generated/Clients.js";
+import { RuntimeState } from "./generated/RuntimeState.js";
+import { Channels, Channel, ChannelUsage, ChannelUse } from "./generated/Channels.js";
+import { RuntimeControl } from "./generated/RuntimeControl.js";
+import { Measures, Measure } from "./generated/Measures.js";
+import { Measurement, Measurement_Window } from "./generated/Measurement.js";
+export class RTIClient extends EventEmitter {
+    get clientId() {
+        return this._clientId;
+    }
+    get user() {
+        return this._user;
+    }
+    get participant() {
+        return this._participant;
+    }
+    get role() {
+        return this._role;
+    }
+    get fullName() {
+        return this._fullName;
+    }
+    get capabilities() {
+        return this._capabilities;
+    }
+    get isConnected() {
+        return this.connected;
+    }
+    get authToken() {
+        return this.socket ? this.socket.authToken : undefined;
+    }
+    get url() {
+        return this._url;
+    }
+    get brokerVersion() {
+        return this._brokerVersion;
+    }
+    get state() {
+        return this._state;
+    }
+    set state(value) {
+        if (value != this._state) {
+            this._state = value;
+            this.publishClient();
+            this.emit("client", this.myClient);
+        }
+    }
+    get usedChannels() {
+        return Object.values(this._usedChannels);
+    }
+    get knownChannels() {
+        return Object.values(this._knownChannels);
+    }
+    get knownClients() {
+        return Object.values(this._knownClients);
+    }
+    get usedMeasures() {
+        return Object.values(this._usedMeasures);
+    }
+    get knownMeasures() {
+        return Object.values(this._knownMeasures);
+    }
+    get compatibilityMode() {
+        return this._compatibilityMode;
+    }
+    get ownChannelPrefix() {
+        return `@${this.clientId}:`;
+    }
+    constructor(options) {
+        super();
+        this.application = "typescript";
+        this.applicationVersion = "";
+        this.integrationVersion = "";
+        this.engineVersion = "";
+        this._user = undefined;
+        this._secret = undefined;
+        this._password = undefined;
+        this._participant = undefined;
+        this._role = undefined;
+        this._fullName = undefined;
+        this._capabilities = [];
+        this.incognito = false;
+        this.incognitoChannels = false;
+        this.connected = false;
+        this._brokerVersion = undefined;
+        this._state = RuntimeState.UNKNOWN;
+        this._usedChannels = {};
+        this._knownChannels = {};
+        this._knownClients = {};
+        this._usedMeasures = {};
+        this._knownMeasures = {};
+        this._compatibilityMode = false;
+        this.measurementIntervalTimeScale = 1;
+        this.collectMeasurementsInterval = undefined;
+        this.collectQueue = {};
+        this.lastCollect = {};
+        this.die = false;
+        this._handlers = {};
+        const env = typeof process === "undefined" ? {} : process.env || {};
+        var url = options && options.url;
+        if (!url)
+            url = env["RTI_URL"];
+        if (!url && typeof location == "object" && location.host) {
+            if (location.protocol == "https:") {
+                url = `wss://${location.host}`;
+            }
+            else if (location.protocol == "app:" && location.hostname == ".") {
+                url = `ws://localhost:${constants.defaultPort}`;
+            }
+            else if (location.hostname && location.hostname.startsWith("127.")) {
+                url = `ws://${location.hostname}:${constants.defaultPort}`;
+            }
+            else if (location.host && location.host != "localhost" && !location.host.startsWith("localhost:")) {
+                url = `ws://${location.host}`;
+            }
+        }
+        if (!url)
+            url = `ws://${constants.defaultHost}:${constants.defaultPort}`;
+        if (!url.startsWith("ws://") && !url.startsWith("wss://"))
+            url = `ws://${url}`;
+        this._url = url;
+        if (options && options.application)
+            this.application = options.application;
+        if (options && options.applicationVersion)
+            this.applicationVersion = options.applicationVersion;
+        if (options && options.integrationVersion)
+            this.integrationVersion = options.integrationVersion;
+        if (options && options.engineVersion)
+            this.engineVersion = options.engineVersion;
+        if (options && options.incognito)
+            this.incognito = options.incognito;
+        if (options && options.incognitoChannels)
+            this.incognitoChannels = options.incognitoChannels;
+        this._clientId = "";
+        if (!this._clientId && options && options.clientId)
+            this._clientId = options.clientId;
+        this.federation = "";
+        if (!this.federation && options && options.federation)
+            this.federation = options.federation;
+        if (!this.federation)
+            this.federation = env["RTI_FEDERATION"] || "";
+        if (this.federation)
+            this.federation = this.federation.replace("/", "_");
+        this.host = "";
+        if (!this.host && options && options.host)
+            this.host = options.host;
+        if (!this.host)
+            this.host = env["RTI_HOST"] || "";
+        if (this.host && this.host.indexOf(".") >= 0)
+            this.host = this.host.split(".")[0];
+        this.station = "";
+        if (!this.station && options && options.station)
+            this.station = options.station;
+        if (!this.station)
+            this.station = env["RTI_STATION"] || "";
+        if (!this._user && options && options.user)
+            this._user = options.user;
+        if (!this._participant && options && options.participant)
+            this._participant = options.participant;
+        if (!this._role && options && options.role)
+            this._role = options.role;
+        if (!this._fullName && options && options.fullName)
+            this._fullName = options.fullName;
+        if (options && options.capabilities)
+            this._capabilities = options.capabilities;
+        let secret = env["RTI_SECRET"];
+        if (!secret && options && options.secret)
+            secret = options.secret;
+        this._secret = secret;
+        const socketOptions = {};
+        var u = new URL(this._url);
+        socketOptions.port = parseInt(u.port);
+        socketOptions.hostname = u.hostname;
+        socketOptions.secure = u.protocol == "wss:" || u.protocol == "https:";
+        socketOptions.path = u.pathname;
+        if (options && typeof options.connect !== "undefined") {
+            socketOptions.autoConnect = options.connect;
+        }
+        this.socket = new AGClientSocket(socketOptions);
+        this.setupSocket();
+    }
+    setupSocket() {
+        var _a, _b;
+        const tokenData = () => {
+            if (!this._clientId)
+                this._clientId = uuidv4();
+            const authToken = {};
+            if (this._secret)
+                authToken.secret = this._secret;
+            if (this._user)
+                authToken.user = this._user;
+            if (this._password)
+                authToken.password = this._password;
+            if (this._participant)
+                authToken.participant = this._participant;
+            if (this._fullName)
+                authToken.fullName = this._fullName;
+            if (this._role)
+                authToken.role = this._role;
+            authToken.application = this.application;
+            authToken.clientId = this.clientId;
+            authToken.clientLibraryVersion = constants.version;
+            if (this.federation)
+                authToken.federation = this.federation;
+            return authToken;
+        };
+        this.forAwait(this.socket.listener("error"), (error) => {
+            this.emit("error", typeof error == "object" && "error" in error ? error.error : error);
+        });
+        this.forAwait(this.socket.listener("connect"), (event) => {
+            const token = this.socket.authToken;
+            if ((!token && !this.socket.signedAuthToken) || (this._clientId && token && this._clientId != token.clientId) || (this._user && token && this._user != token.user)) {
+                this.socket.transmit("auth", tokenData());
+            }
+        });
+        this.forAwait(this.socket.listener("close"), (event) => {
+            this.connected = false;
+            this.emit("disconnect");
+        });
+        this.forAwait(this.socket.listener("authenticate"), (event) => {
+            const token = this.socket.authToken;
+            if (token.user && this._user && this._user != token.user) {
+                this.socket.deauthenticate();
+            }
+            else {
+                if (token.clientId && this._clientId != token.clientId) {
+                    if (this._clientId)
+                        console.warn("RTI authenticated with unexpected client id", token.clientId);
+                    this._clientId = token.clientId;
+                }
+                if (token.user)
+                    this._user = token.user;
+                if ("secret" in token)
+                    this._secret = undefined;
+                if ("password" in token)
+                    this._password = undefined;
+                this.emit("authenticate");
+                if (!this.connected) {
+                    this.connected = true;
+                    if (!this.incognito && this.clientId) {
+                        this.publishClient();
+                        this.publishMeasures();
+                    }
+                    if (this.federation)
+                        this.publishText(RTIchannel.federations, this.federation, false);
+                    this.emit("connect");
+                }
+            }
+        });
+        this.forAwait(this.socket.receiver("fail"), (error) => {
+            this.emit("error", typeof error == "object" && "error" in error ? error.error : error);
+            this.disconnect();
+        });
+        this.forAwait(this.socket.receiver("ping"), (content) => {
+            this.socket.transmit("pong", content);
+        });
+        this.forAwait(this.socket.receiver("broker-version"), (content) => {
+            this._brokerVersion = content;
+            this.emit("broker-version", content);
+        });
+        if ((_a = this.socket.transport) === null || _a === void 0 ? void 0 : _a.socket) {
+            const sockSocket = (_b = this.socket.transport) === null || _b === void 0 ? void 0 : _b.socket;
+            sockSocket.addEventListener("message", (message) => {
+                if (message.data === "#1") {
+                    this.socket.send("#2");
+                    if (!this._compatibilityMode) {
+                        this._compatibilityMode = true;
+                        this.emit("compatibility-mode", this._compatibilityMode);
+                        this.socket.transport.pingTimeoutDisabled = true;
+                        clearInterval(this.socket.transport._pingTimeoutTicker);
+                    }
+                }
+            });
+        }
+        this.subscribe(RTIchannel.clients, Clients, (m) => this.onClients(m), false);
+        this.subscribe(RTIchannel.channels, Channels, (m) => this.onChannels(m), false);
+        this.subscribe(RTIchannel.measures, Measures, (m) => this.onMeasures(m), false);
+        this.subscribeText(RTIchannel.federations, (message) => {
+            if (message == "?")
+                this.publishText(RTIchannel.federations, this.federation, false);
+        }, false);
+    }
+    forAwait(iterable, handler) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, iterable_1, iterable_1_1;
+            var _b, e_1, _c, _d;
+            try {
+                for (_a = true, iterable_1 = __asyncValues(iterable); iterable_1_1 = yield iterable_1.next(), _b = iterable_1_1.done, !_b; _a = true) {
+                    _d = iterable_1_1.value;
+                    _a = false;
+                    let item = _d;
+                    if (this.die || handler(item) === false)
+                        break;
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_a && !_b && (_c = iterable_1.return)) yield _c.call(iterable_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        });
+    }
+    kill() {
+        if (this.socket.state == "open")
+            this.socket.disconnect();
+        this.socket.killAllChannels();
+        this.socket.killAllListeners();
+        this.socket.killAllReceivers();
+        this.socket.killAllProcedures();
+        this.die = true;
+        this.connected = false;
+    }
+    invoke(event, data, options) {
+        return this.socket.invoke(event, data, options);
+    }
+    getToken(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.socket.invoke("gettoken", data);
+            return result;
+        });
+    }
+    verifyToken(token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.socket.invoke("verifytoken", token);
+            return result;
+        });
+    }
+    onClients(message) {
+        if (message.requestClients) {
+            if (!this.incognito && this.clientId)
+                this.publishClient();
+        }
+        else if (message.client) {
+            this._knownClients[message.client.id] = message.client;
+            this.emit("client", message.client);
+        }
+        else if (message.logClient) {
+            if (!(message.logClient.id in this._knownClients)) {
+                this._knownClients[message.logClient.id] = message.logClient;
+                this.emit("logclient", message.logClient);
+            }
+        }
+        else if (message.registerParticipant) {
+            const reg = message.registerParticipant;
+            if ((!reg.clientId || reg.clientId == this.clientId) &&
+                (!reg.host || reg.host == this.host) &&
+                (!reg.station || reg.station == this.station) &&
+                (reg.participant != this.participant || reg.role != this.role || reg.fullName != this.fullName)) {
+                this._participant = reg.participant;
+                this._role = reg.role;
+                this._fullName = reg.fullName;
+                this.publishClient();
+                this.emit("client", this.myClient);
+            }
+        }
+    }
+    onChannels(message) {
+        if (message.requestChannelUsage && !this.incognito && !this.incognitoChannels) {
+            const usage = ChannelUsage.create({ clientId: this.clientId });
+            for (const use of Object.values(this._usedChannels)) {
+                usage.usage.push(use);
+            }
+            this.publish(RTIchannel.channels, Channels, { channelUsage: usage }, false);
+        }
+        else if (message.channelUsage) {
+            for (const usage of message.channelUsage.usage) {
+                this.discoverChannel(usage.channel);
+                this.emit("channel", usage.channel);
+            }
+        }
+        else if (message.channel) {
+            this.discoverChannel(message.channel);
+            this.emit("channel", message.channel);
+        }
+        else if (message.logChannel) {
+            if (!(message.logChannel.name in this._knownChannels)) {
+                this.discoverChannel(message.logChannel);
+                this.emit("logchannel", message.logChannel);
+            }
+        }
+    }
+    onMeasures(message) {
+        if (message.requestMeasures) {
+            if (!this.incognito) {
+                this.publishMeasures();
+            }
+            else if (message.measure) {
+                this._knownMeasures[message.measure.id] = message.measure;
+                this.emit("measure", message.measure);
+            }
+            else if (message.logMeasure) {
+                if (!(message.logMeasure.id in this._knownMeasures)) {
+                    this._knownMeasures[message.logMeasure.id] = message.logMeasure;
+                    this.emit("logmeasure", message.logMeasure);
+                }
+            }
+        }
+    }
+    publishClient() {
+        this.publish(RTIchannel.clients, Clients, { client: this.myClient }, false);
+    }
+    publishMeasures() {
+        for (const measure of Object.values(this._knownMeasures)) {
+            this.publish(RTIchannel.measures, Measures, { measure }, false);
+        }
+    }
+    get myClient() {
+        return Client.create({
+            id: this.clientId,
+            state: this._state,
+            host: this.host,
+            station: this.station,
+            user: this.user,
+            participant: this.participant,
+            role: this.role,
+            fullName: this.fullName,
+            application: this.application,
+            applicationVersion: this.applicationVersion,
+            clientLibraryVersion: constants.version,
+            integrationVersion: this.integrationVersion,
+            engineVersion: !this.engineVersion && typeof process !== "undefined" && process.version ? `Node ${process.version}` : this.engineVersion,
+            userAgent: typeof navigator !== "undefined" && navigator.userAgent ? navigator.userAgent : "",
+            capabilities: this.capabilities,
+        });
+    }
+    publishError(errorMessage, errorState) {
+        this.publish(RTIchannel.control, RuntimeControl, {
+            error: {
+                clientId: this.clientId,
+                message: errorMessage,
+                errorState,
+            },
+        }, false);
+    }
+    publishHeartbeat() {
+        this.publish(RTIchannel.clients, Clients, { clientHeartbeat: { clientId: this.clientId } }, false);
+    }
+    publishProgress(progress) {
+        this.publish(RTIchannel.clients, Clients, { progress: { clientId: this.clientId, progress } }, false);
+    }
+    publishValue(value, highlight = false, error = false) {
+        this.publish(RTIchannel.clients, Clients, { value: { clientId: this.clientId, value, highlight, error } }, false);
+    }
+    changePassword(oldPassword, newPassword) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.socket.invoke("passwd", { oldPassword, newPassword });
+            return result;
+        });
+    }
+    subscribe(channelName, type, handler, register = true) {
+        if (!type)
+            throw new Error("cannot subscribe with undefined type");
+        if (register)
+            this.registerChannelUsage(channelName, false, type.name);
+        return this.doSubscribe(channelName, (message) => {
+            const data = RTIClient.parse(type, message);
+            if (handler.length == 2) {
+                handler(channelName, data);
+            }
+            else {
+                handler(data);
+            }
+        });
+    }
+    static parse(type, content) {
+        return type.decode(base64.toByteArray(content));
+    }
+    subscribeText(channelName, handler, register = true) {
+        if (register)
+            this.registerChannelUsage(channelName, false, "text");
+        return this.doSubscribe(channelName, handler);
+    }
+    subscribeJSON(channelName, handler, register = true) {
+        if (register)
+            this.registerChannelUsage(channelName, false, "json");
+        return this.doSubscribe(channelName, (message) => {
+            const data = JSON.parse(message);
+            if (handler.length == 2) {
+                handler(channelName, data);
+            }
+            else {
+                handler(data);
+            }
+        });
+    }
+    doSubscribe(channelName, handler) {
+        const channel = this.socket.subscribe((this.federation && channelName != RTIchannel.federations ? "//" + this.federation + "/" : "") + channelName);
+        const wrappedHandler = (data) => {
+            try {
+                if (handler.length == 2) {
+                    handler(channelName, data);
+                }
+                else {
+                    handler(data);
+                }
+            }
+            catch (error) {
+                this.emit("error", error);
+            }
+        };
+        if (!(channelName in this._handlers))
+            this._handlers[channelName] = [];
+        this._handlers[channelName].push(handler);
+        this.forAwait(channel, (data) => {
+            if (this._handlers[channelName].indexOf(handler) < 0)
+                return false;
+            wrappedHandler(data);
+        });
+        return { channel, handler };
+    }
+    unsubscribe(channelNameOrSubscription) {
+        if (typeof channelNameOrSubscription === "string") {
+            this.socket.unsubscribe(channelNameOrSubscription);
+        }
+        else {
+            const subscription = channelNameOrSubscription;
+            const channel = subscription.channel;
+            if (channel) {
+                const handlers = this._handlers[channel.name];
+                if (handlers && handlers.length > 0) {
+                    const index = handlers.indexOf(subscription.handler);
+                    if (index >= 0)
+                        handlers.splice(index, 1);
+                    if (handlers.length == 0)
+                        channel.unsubscribe();
+                }
+            }
+        }
+    }
+    publish(channelName, typeOrEncode, data, register = true, typeName) {
+        if (register)
+            this.registerChannelUsage(channelName, true, typeName || "proto");
+        let bytes;
+        if (typeOrEncode.encode) {
+            if (typeOrEncode.fromPartial)
+                data = typeOrEncode.fromPartial(data);
+            bytes = typeOrEncode.encode(data);
+        }
+        else {
+            bytes = typeOrEncode;
+        }
+        if (bytes.finish)
+            bytes = bytes.finish();
+        this.doPublish(channelName, base64.fromByteArray(bytes));
+    }
+    publishBytes(channelName, bytes, register = true, typeName) {
+        if (register)
+            this.registerChannelUsage(channelName, true, typeName || "bytes");
+        if (bytes.finish)
+            bytes = bytes.finish();
+        this.doPublish(channelName, base64.fromByteArray(bytes));
+    }
+    publishText(channelName, message, register = true) {
+        if (register)
+            this.registerChannelUsage(channelName, true, "text");
+        this.doPublish(channelName, message);
+    }
+    publishJSON(channelName, message, register = true) {
+        if (register)
+            this.registerChannelUsage(channelName, true, "json");
+        this.doPublish(channelName, JSON.stringify(message));
+    }
+    doPublish(channelName, message) {
+        if (this.federation && !channelName.startsWith("@") && channelName != RTIchannel.federations)
+            channelName = "//" + this.federation + "/" + channelName;
+        this.socket.transmitPublish(channelName, message);
+    }
+    connect() {
+        this.socket.connect();
+    }
+    disconnect() {
+        this.socket.disconnect();
+    }
+    setCredentials(user, password) {
+        this._user = user;
+        this._password = password;
+        this.socket.deauthenticate();
+    }
+    logout() {
+        this._user = undefined;
+        this._password = undefined;
+        this.socket.deauthenticate();
+        this.socket.disconnect();
+        setTimeout(() => this.socket.connect(), 100);
+    }
+    registerChannelUsage(channelName, usePublish, type) {
+        let channel;
+        if (typeof channelName === "string") {
+            if (channelName in this._knownChannels) {
+                channel = this._knownChannels[channelName];
+            }
+            else {
+                channel = Channel.create({ name: channelName });
+            }
+        }
+        else {
+            channel = channelName;
+        }
+        if (type)
+            channel.dataType = type;
+        if (channel.name.startsWith("@"))
+            return;
+        let use = this._usedChannels[channel.name];
+        if (!use)
+            use = ChannelUse.create();
+        use.channel = channel;
+        this._usedChannels[channel.name] = use;
+        if (usePublish)
+            use.publish = true;
+        else
+            use.subscribe = true;
+        if (!(channel.name in this._knownChannels))
+            this.registerChannel(channel);
+    }
+    registerChannel(channel) {
+        if (channel.name.startsWith("@"))
+            return;
+        this._knownChannels[channel.name] = channel;
+        if (!(channel.name in this._usedChannels))
+            this._usedChannels[channel.name] = ChannelUse.create();
+        const use = this._usedChannels[channel.name];
+        use.channel = channel;
+        if (this.connected && !this.incognito) {
+            this.publish(RTIchannel.channels, Channels, { channel }, false);
+        }
+    }
+    discoverChannel(channel) {
+        if (!(channel.name in this._knownChannels)) {
+            this._knownChannels[channel.name] = channel;
+        }
+        else {
+            const known = this._knownChannels[channel.name];
+            if (channel.dataType && !known.dataType)
+                known.dataType = channel.dataType;
+            if (channel.ephemeral)
+                known.ephemeral = true;
+            if (channel.state)
+                known.state = true;
+            if (channel.firstFieldId)
+                known.firstFieldId = true;
+        }
+    }
+    registerParticipant(participant, role, fullName) {
+        const registration = ParticipantRegistration.create({
+            participant,
+            role,
+            fullName,
+            clientId: this.clientId,
+            station: this.station,
+            host: this.host,
+        });
+        this.publish(RTIchannel.clients, Clients, { registerParticipant: registration }, false);
+        this._participant = participant;
+        this._role = role;
+        this._fullName = fullName;
+        this.publishClient();
+    }
+    registerMeasure(measure) {
+        measure.application = this.application;
+        this._usedMeasures[measure.id] = measure;
+        if (!(measure.id in this._knownMeasures)) {
+            this._knownMeasures[measure.id] = measure;
+            if (this.connected && !this.incognito) {
+                this.publish(RTIchannel.measures, Measures, { measure }, false);
+            }
+        }
+    }
+    measure(measureOrId, value) {
+        let measure = undefined;
+        if (typeof measureOrId == "string") {
+            measure = this._usedMeasures[measureOrId];
+            if (!measure)
+                measure = this._knownMeasures[measureOrId];
+            if (!measure) {
+                measure = Measure.create({ id: measureOrId, application: this.application });
+            }
+        }
+        else {
+            measure = measureOrId;
+        }
+        if (!measure)
+            return;
+        if (!(measure.id in this._usedMeasures))
+            this.registerMeasure(measure);
+        if (measure.interval > 1e-5) {
+            if (!this.collectMeasurementsInterval)
+                this.collectMeasurementsInterval = setInterval(() => this.collectMeasurements(), 500);
+            if (!(measure.id in this.collectQueue))
+                this.collectQueue[measure.id] = [];
+            this.collectQueue[measure.id].push(value);
+        }
+        else {
+            const measurement = Measurement.create({ measureId: measure.id, clientId: this.clientId, value });
+            const channel = measure.channel || RTIchannel.measurement;
+            if (this.connected)
+                this.publish(channel, Measurement, measurement, false);
+        }
+    }
+    collectMeasurements() {
+        if (!this.connected && this.collectMeasurementsInterval) {
+            clearInterval(this.collectMeasurementsInterval);
+            this.collectMeasurementsInterval = undefined;
+            return;
+        }
+        for (const id in this.collectQueue) {
+            if (!(id in this.lastCollect)) {
+                this.lastCollect[id] = new Date().getTime();
+            }
+            else {
+                const measure = this._knownMeasures[id];
+                if ((new Date().getTime() - this.lastCollect[id]) * this.measurementIntervalTimeScale > measure.interval * 1000) {
+                    const channel = measure.channel || RTIchannel.measurement;
+                    const measurement = Measurement.create({ measureId: id, clientId: this.clientId });
+                    const values = this.collectQueue[id];
+                    if (values.length == 1) {
+                        measurement.value = values.pop();
+                        this.publish(channel, Measurement, measurement, false);
+                    }
+                    else if (values.length > 1) {
+                        const window = Measurement_Window.create({ min: Infinity, max: -Infinity, count: values.length });
+                        for (const value of values) {
+                            window.mean += value;
+                            if (value > window.max)
+                                window.max = value;
+                            if (value < window.min)
+                                window.min = value;
+                        }
+                        this.collectQueue[id] = [];
+                        if (window.count > 0)
+                            window.mean /= window.count;
+                        window.duration = (new Date().getTime() - this.lastCollect[id]) * this.measurementIntervalTimeScale;
+                        measurement.window = window;
+                        this.publish(channel, Measurement, measurement, false);
+                    }
+                    this.lastCollect[id] = new Date().getTime();
+                }
+            }
+        }
+    }
+    whenConnected(callback) {
+        if (this.connected)
+            callback();
+        else
+            this.once("connect", () => callback());
+    }
+    resetKnown() {
+        this._knownChannels = {};
+        this._knownClients = {};
+        this._knownMeasures = {};
+    }
+}
+//# sourceMappingURL=rticlient.js.map