Use strict type checking

This commit is contained in:
Hornwitser committed 2023-08-12 02:31:17 +02:00
1 parent 2ca8e69025
commit a66e930997
36 files changed
+714 -676

No files matched your search

+2
View File
@@ -0,0 +1,2 @@
import ws = require("ws");
export = ws;
+3
View File
@@ -0,0 +1,3 @@
"use strict";
// eslint-disable-next-line node/no-process-env
module.exports = process.env.APP_ENV === "browser" ? window.WebSocket : require("ws");
+41 -37
View File
@@ -2,14 +2,13 @@
"use strict";
import { strict as assert } from "assert";
import events from "events";
// eslint-disable-next-line node/no-process-env
// @ts-ignore
const WebSocket = process.env.APP_ENV === "browser" ? window.WebSocket : require("ws");
import WebSocket from "./WebSocket";
import * as libData from "../data";
import * as libErrors from "../errors";
import { logger } from "../logging";
import ExponentialBackoff from "../ExponentialBackoff";
import type { Request, Event } from "./link";
/**
@@ -37,15 +36,15 @@ export abstract class BaseConnector extends events.EventEmitter {
abstract send(message: libData.Message): void;
sendRequest(
request: libData.Request,
sendRequest<Req, Res>(
request: Request<Req, Res>,
requestId: number,
dst: libData.Address
) {
let seq = this._seq;
this._seq += 1;
let src = new libData.Address(this.src.type, this.src.id, requestId);
let Request = request.constructor as typeof libData.Request;
let Request = request.constructor;
let name = Request.plugin ? `${Request.plugin}:${Request.name}` : Request.name;
let hasData = Boolean(Request.jsonSchema);
const message = new libData.MessageRequest(seq, src, dst, name, hasData ? request : undefined);
@@ -69,10 +68,10 @@ export abstract class BaseConnector extends events.EventEmitter {
return seq;
}
sendEvent(event: libData.Event, dst: libData.Address) {
sendEvent<T>(event: Event<T>, dst: libData.Address) {
let seq = this._seq;
this._seq += 1;
let Event = event.constructor as typeof libData.Event;
let Event = event.constructor;
let name = Event.plugin ? `${Event.plugin}:${Event.name}` : Event.name;
let hasData = Boolean(Event.jsonSchema);
const message = new libData.MessageEvent(seq, this.src, dst, name, hasData ? event : undefined);
@@ -82,6 +81,12 @@ export abstract class BaseConnector extends events.EventEmitter {
}
type ConnectorState = "closed" | "connecting" | "connected" | "resuming";
type ReliableMessages =
| libData.MessageRequest
| libData.MessageResponse
| libData.MessageResponseError
| libData.MessageEvent
;
/**
* Base connector for links
@@ -92,12 +97,12 @@ export abstract class WebSocketBaseConnector extends BaseConnector {
// One of closed, connecting (client only), connected and resuming.
_state: ConnectorState = "closed";
_closing = false;
_socket = null;
_lastHeartbeat = null;
_heartbeatId: NodeJS.Timer = null;
_socket: WebSocket | null = null;
_lastHeartbeat: number | null = null;
_heartbeatId: NodeJS.Timer | null = null;
_heartbeatInterval: number | null = null;
_lastReceivedSeq = undefined;
_sendBuffer = [];
_sendBuffer: (ReliableMessages)[] = [];
constructor(src: libData.Address, dst: libData.Address) {
super(src, dst);
@@ -194,13 +199,13 @@ export abstract class WebSocketBaseConnector extends BaseConnector {
_doHeartbeat() {
this._check("connected");
if (Date.now() - this._lastHeartbeat > 2000 * this._heartbeatInterval) {
if (Date.now() - this._lastHeartbeat! > 2000 * this._heartbeatInterval!) {
logger.verbose("Connector | closing after heartbeat timed out");
// eslint-disable-next-line node/no-process-env
if (process.env.APP_ENV === "browser") {
this._socket.close(4008, "Heartbeat timeout");
this._socket!.close(4008, "Heartbeat timeout");
} else {
this._socket.terminate();
this._socket!.terminate();
}
} else {
@@ -223,7 +228,7 @@ export abstract class WebSocketBaseConnector extends BaseConnector {
this._lastHeartbeat = Date.now();
this._heartbeatId = setInterval(() => {
this._doHeartbeat();
}, this._heartbeatInterval * 1000);
}, this._heartbeatInterval! * 1000);
}
/**
@@ -244,7 +249,7 @@ export abstract class WebSocketBaseConnector extends BaseConnector {
*
* @param message - Message to send.
*/
send(message: libData.Message) {
send(message: ReliableMessages) {
if (!["connected", "resuming"].includes(this._state)) {
throw new libErrors.SessionLost("No session");
}
@@ -256,7 +261,7 @@ export abstract class WebSocketBaseConnector extends BaseConnector {
}
_sendInternal(message: libData.Message) {
this._socket.send(JSON.stringify(message));
this._socket!.send(JSON.stringify(message));
}
/**
@@ -280,9 +285,9 @@ export abstract class WebSocketBaseConnector extends BaseConnector {
}
this.setClosing();
this.send(new libData.MessageDisconnect("prepare"));
this._sendInternal(new libData.MessageDisconnect("prepare"));
let timeout: NodeJS.Timeout;
let timeout: NodeJS.Timeout | undefined;
let waitTimeout = new Promise(resolve => { timeout = setTimeout(resolve, 10000); }); // Make Configurable?
try {
await Promise.race([
@@ -326,7 +331,7 @@ export abstract class WebSocketBaseConnector extends BaseConnector {
* @extends module:lib.WebSocketBaseConnector
*/
export abstract class WebSocketClientConnector extends WebSocketBaseConnector {
_reconnectId: NodeJS.Timeout | null = null;
_reconnectId?: NodeJS.Timeout;
_sessionToken: string | null = null;
_sessionTimeout: number | null = null;
_startedResuming: number | null = null;
@@ -337,7 +342,7 @@ export abstract class WebSocketClientConnector extends WebSocketBaseConnector {
maxReconnectDelay: number,
protected _tlsCa = null
) {
super(undefined, new libData.Address(libData.Address.controller, 0));
super(undefined as any, new libData.Address(libData.Address.controller, 0));
this._backoff = new ExponentialBackoff({ max: maxReconnectDelay });
// The following states are used in the client connector
@@ -349,21 +354,21 @@ export abstract class WebSocketClientConnector extends WebSocketBaseConnector {
_reset() {
clearTimeout(this._reconnectId);
this._reconnectId = null;
this._reconnectId = undefined;
this._sessionToken = null;
this._sessionTimeout = null;
this._startedResuming = null;
super._reset();
this.src = undefined;
this.src = undefined as any;
}
_invalidate() {
assert(this._reconnectId === null);
assert(this._reconnectId === undefined);
this._sessionToken = null;
this._sessionTimeout = null;
this._startedResuming = null;
super._invalidate();
this.src = undefined;
this.src = undefined as any;
}
/**
@@ -394,7 +399,7 @@ export abstract class WebSocketClientConnector extends WebSocketBaseConnector {
this._closing = true;
if (this._state === "connected" || this._socket) {
this._socket.close(code, reason);
this._socket!.close(code, reason);
await events.once(this, "close");
} else {
@@ -421,7 +426,7 @@ export abstract class WebSocketClientConnector extends WebSocketBaseConnector {
}
if (this._socket) {
this._socket.close(1000, "Connector closing");
this._socket!.close(1000, "Connector closing");
} else {
this._reset();
@@ -471,14 +476,14 @@ export abstract class WebSocketClientConnector extends WebSocketBaseConnector {
throw new Error("Cannot reconnect while socket is open");
}
if (this._reconnectId !== null) {
if (this._reconnectId !== undefined) {
logger.error("Unexpected double call to reconnect");
}
let delay = this._backoff.delay();
if (
this._state === "resuming"
&& this._startedResuming + this._sessionTimeout * 1000 < Date.now() + delay
&& this._startedResuming! + this._sessionTimeout! * 1000 < Date.now() + delay
) {
logger.error("Connector | Session timed out trying to resume");
this._reset();
@@ -494,14 +499,13 @@ export abstract class WebSocketClientConnector extends WebSocketBaseConnector {
`Connector | waiting ${(Math.round(delay / 10) / 100)} seconds for reconnect`
);
this._reconnectId = setTimeout(() => {
this._reconnectId = null;
this._reconnectId = undefined;
this._doConnect();
}, delay);
}
_attachSocketHandlers() {
// TODO type event
this._socket.onclose = (event: any) => {
this._socket!.onclose = (event) => {
const previousState = this._state;
// Authentication failed
@@ -544,7 +548,7 @@ export abstract class WebSocketClientConnector extends WebSocketBaseConnector {
}
};
this._socket.onerror = (event: any) => {
this._socket!.onerror = (event) => {
// It's assumed that close is always called by ws
let code = !event.error ? "" : `, code: ${event.error.code}`;
let message = `Connector | Socket error: ${event.message || "unknown error"}${code}`;
@@ -568,13 +572,13 @@ export abstract class WebSocketClientConnector extends WebSocketBaseConnector {
}
};
this._socket.onopen = () => {
this._socket!.onopen = () => {
logger.verbose("Connector | Open");
};
// Handle messages
this._socket.onmessage = (event: any) => {
let message = this._parseMessage(event.data);
this._socket!.onmessage = (event) => {
let message = this._parseMessage(event.data as string);
if (!message) {
return;
}
+98 -61
View File
@@ -7,13 +7,42 @@ import { dataClasses } from "./messages";
import { BaseConnector, WebSocketBaseConnector } from "./connectors";
import { strict as assert } from "assert";
import type { PluginInfo } from "../plugin";
import type { User } from "../users";
import type { AddressType, JSONDeserialisable, Message, MessageRequest, MessageEvent } from "../data";
export interface Request<Req, Res> {
constructor: Partial<JSONDeserialisable<Request<Req, Res>>> & {
new (...args: any): Request<Req, Res>,
name: string,
type: "request";
src: AddressType | readonly AddressType[];
dst: AddressType | readonly AddressType[];
permission?: null | string | ((user: User, message: MessageRequest) => void);
plugin?: string;
Response?: JSONDeserialisable<Res>,
}
}
export type RequestClass<Req, Res> = Request<Req, Res>["constructor"];
export interface Event<T> {
constructor: Partial<JSONDeserialisable<Event<T>>> & {
new (...args: any): Event<T>,
name: string,
type: "event";
src: AddressType | readonly AddressType[];
dst: AddressType | readonly AddressType[];
permission?: null | string | ((user: User, message: MessageEvent) => void);
plugin?: string;
}
}
export type EventClass<T> = Event<T>["constructor"];
interface RequestEntry {
Request: typeof libData.Request;
Request: RequestClass<unknown, unknown>;
name: string,
allowedSrcTypes: Set<number>;
allowedDstTypes: Set<number>;
requestFromJSON: (json: any) => libData.Request;
requestFromJSON: (json: any) => Request<unknown, unknown>;
Response?: any;
responseFromJSON: (json: any) => any;
}
@@ -32,14 +61,18 @@ interface ForwardedRequest {
}
interface EventEntry {
Event: typeof libData.Event;
Event: EventClass<unknown>;
name: string,
allowedSrcTypes: Set<number>;
allowedDstTypes: Set<number>;
eventFromJSON: (json: any) => libData.Event;
eventFromJSON: (json: any) => Event<unknown>;
}
type RequestHandler<Req, Res> = (request: Request<Req, Res>, src: libData.Address, dst: libData.Address) => any;
type EventHandler<T> = (event: Event<T>, src: libData.Address, dst: libData.Address) => any;
interface Router {
forwardMessage(origin: Link, message: Message, fallback: boolean): boolean,
}
type RequestHandler = (request: libData.Request, src: libData.Address, dst: libData.Address) => any;
type EventHandler = (request: libData.Event, src: libData.Address, dst: libData.Address) => any;
// Some definitions for the terminology used here:
// link: Either side of a controller - client connection
@@ -52,7 +85,7 @@ type EventHandler = (request: libData.Event, src: libData.Address, dst: libData.
* Common interface for server and client connections
*/
export class Link {
router = undefined;
router?: Router = undefined;
validateSent = true;
_requestHandlers = new Map();
@@ -66,7 +99,6 @@ export class Link {
constructor(
public connector: BaseConnector
) {
// @ts-ignore: TODO Remove when lib/data is migrated to ts
this.handle(libData.PingRequest, () => {});
// Process messages received by the connector
@@ -207,7 +239,7 @@ export class Link {
throw new libErrors.InvalidMessage("Message src may not be broadcast");
}
this.validateIngress(message);
} catch (err) {
} catch (err: any) {
if (message.type === "request") {
this.connector.sendResponseError(new libData.ResponseError(err.message, err.code), message.src);
}
@@ -314,7 +346,7 @@ export class Link {
_processRequest(
message: libData.MessageRequest,
entry: RequestEntry,
handler: RequestHandler,
handler: RequestHandler<unknown, unknown>,
spoofedSrc?: libData.Address
) {
if (!handler) {
@@ -327,7 +359,7 @@ export class Link {
let response: any;
try {
response = handler(entry.requestFromJSON(message.data), message.src, message.dst);
} catch (err) {
} catch (err: any) {
if (err.errors) {
logger.error(JSON.stringify(err.errors, null, 4));
}
@@ -366,7 +398,7 @@ export class Link {
this.connector.sendResponseError(
new libData.ResponseError(err.message, err.code, err.stack), message.src, spoofedSrc
);
} catch (err) {
} catch (err: any) {
logger.error(`Unexpected error sending error response for ${message.name}:\n${err.stack}`);
}
}
@@ -374,7 +406,7 @@ export class Link {
}
_processResponse(message: libData.MessageResponse) {
let pending = this._pendingRequests.get(message.dst.requestId);
let pending = this._pendingRequests.get(message.dst.requestId!);
if (!pending) {
throw new libErrors.InvalidMessage(
`Received response ${message.dst.requestId} without a pending request`
@@ -387,14 +419,14 @@ export class Link {
try {
pending.resolve(pending.request.responseFromJSON(message.data));
} catch (err) {
} catch (err: any) {
// An invalid response object was likely received
pending.reject(err);
}
}
_processResponseError(message: libData.MessageResponseError) {
let pending = this._pendingRequests.get(message.dst.requestId);
let pending = this._pendingRequests.get(message.dst.requestId!);
if (!pending) {
throw new libErrors.InvalidMessage(
`Received error response ${message.dst.requestId} without a pending request`
@@ -441,10 +473,10 @@ export class Link {
* Promise that resolves to the response if a request was sent or
* undefined if it was an event.
*/
send(requestOrEvent: libData.Request): Promise<unknown>;
send(requestOrEvent: libData.Event): void;
send(requestOrEvent: libData.Request | libData.Event): Promise<unknown> | void {
return this.sendTo(this.connector.dst, requestOrEvent);
send<Req, Res = void>(requestOrEvent: Request<Req, Res>): Promise<Res>;
send<T>(requestOrEvent: Event<T>): void;
send(requestOrEvent: Request<unknown, unknown> | Event<unknown>): Promise<unknown> | void {
return this.sendTo(this.connector.dst, requestOrEvent as any);
}
/**
@@ -456,26 +488,26 @@ export class Link {
* Promise that resolves to the response if a request was sent or
* undefined if it was an event.
*/
sendTo(destination: libData.AddressShorthand, requestOrEvent: libData.Request): Promise<unknown>;
sendTo(destination: libData.AddressShorthand, requestOrEvent: libData.Event): void;
sendTo<Req, Res = void>(destination: libData.AddressShorthand, requestOrEvent: Request<Req, Res>): Promise<Res>;
sendTo<T>(destination: libData.AddressShorthand, requestOrEvent: Event<T>): void;
sendTo(
destination: libData.AddressShorthand,
requestOrEvent: libData.Request | libData.Event,
requestOrEvent: Request<unknown, unknown> | Event<unknown>,
): Promise<unknown> | void {
let dst = libData.Address.fromShorthand(destination);
// TODO investigate if these types can be inferred
if ((requestOrEvent.constructor as any).type === "request") {
return this.sendRequest(requestOrEvent, dst);
if (requestOrEvent.constructor.type === "request") {
return this.sendRequest(requestOrEvent as Request<unknown, unknown>, dst);
}
if ((requestOrEvent.constructor as any).type === "event") {
return this.sendEvent(requestOrEvent, dst);
if (requestOrEvent.constructor.type === "event") {
return this.sendEvent(requestOrEvent as Event<unknown>, dst);
}
throw Error(`Expected request or event but got type ${(requestOrEvent.constructor as any).type}`);
}
sendRequest(request: libData.Request, dst: libData.Address) {
let entry = Link._requestsByClass.get(request.constructor as typeof libData.Request);
sendRequest<Req, Res>(request: Request<Req, Res>, dst: libData.Address) {
let entry = Link._requestsByClass.get(request.constructor as RequestClass<unknown, unknown>);
if (!entry) {
throw new Error(`Attempt to send unregistered Request ${request.constructor.name}`);
}
@@ -492,7 +524,7 @@ export class Link {
let requestId = this._nextRequestId;
this._nextRequestId += 1;
this._pendingRequests.set(
requestId, { request: entry, promise, resolve, reject, dst, }
requestId, { request: entry, promise, resolve: resolve!, reject: reject!, dst, }
);
this.connector.sendRequest(request, requestId, dst);
return promise;
@@ -508,8 +540,8 @@ export class Link {
this.connector.send(message);
}
sendEvent(event: libData.Event, dst: libData.Address) {
let entry = Link._eventsByClass.get(event.constructor as typeof libData.Event);
sendEvent<T>(event: Event<T>, dst: libData.Address) {
let entry = Link._eventsByClass.get(event.constructor as EventClass<unknown>);
if (!entry) {
throw new Error(`Attempt to send unregistered Event ${event.constructor.name}`);
}
@@ -520,23 +552,23 @@ export class Link {
this.connector.sendEvent(event, dst);
}
handle(Class: typeof libData.Request, handler: RequestHandler): void;
handle(Class: typeof libData.Event, handler: EventHandler): void;
handle<Req, Res>(Class: RequestClass<Req, Res>, handler: RequestHandler<Req, Res>): void;
handle<T>(Class: EventClass<T>, handler: EventHandler<T>): void;
handle(
Class: typeof libData.Request | typeof libData.Event,
handler: RequestHandler | EventHandler,
Class: RequestClass<unknown, unknown> | EventClass<unknown>,
handler: RequestHandler<unknown, unknown> | EventHandler<unknown>,
) {
if (Class.type === "request") {
this.handleRequest(Class, handler);
this.handleRequest(Class, handler as RequestHandler<unknown, unknown>);
} else if (Class.type === "event") {
this.handleEvent(Class, handler);
this.handleEvent(Class, handler as EventHandler<unknown>);
} else {
throw new Error(`Class ${(Class as any).name} has unrecognized type ${(Class as any).type}`);
}
}
handleRequest(Request: typeof libData.Request, handler: RequestHandler) {
let entry = Link._requestsByClass.get(Request);
handleRequest<Req, Res>(Request: RequestClass<Req, Res>, handler: RequestHandler<Req, Res>) {
let entry = Link._requestsByClass.get(Request as RequestClass<unknown, unknown>);
if (!entry) {
throw new Error(`Unregistered Request class ${Request.name}`);
}
@@ -546,8 +578,8 @@ export class Link {
this._requestHandlers.set(Request, handler);
}
fallbackRequest(Request: typeof libData.Request, handler: RequestHandler) {
let entry = Link._requestsByClass.get(Request);
fallbackRequest<Req, Res>(Request: RequestClass<Req, Res>, handler: RequestHandler<Req, Res>) {
let entry = Link._requestsByClass.get(Request as RequestClass<unknown, unknown>);
if (!entry) {
throw new Error(`Unregistered Request class ${Request.name}`);
}
@@ -557,8 +589,8 @@ export class Link {
this._requestFallbacks.set(Request, handler);
}
handleEvent(Event: typeof libData.Event, handler: EventHandler) {
let entry = Link._eventsByClass.get(Event);
handleEvent<T>(Event: EventClass<T>, handler: EventHandler<T>) {
let entry = Link._eventsByClass.get(Event as EventClass<unknown>);
if (!entry) {
throw new Error(`Unregistered Event class ${Event.name}`);
}
@@ -568,8 +600,8 @@ export class Link {
this._eventHandlers.set(Event, handler);
}
snoopEvent(Event: typeof libData.Event, handler: EventHandler) {
let entry = Link._eventsByClass.get(Event);
snoopEvent<T>(Event: EventClass<T>, handler: EventHandler<T>) {
let entry = Link._eventsByClass.get(Event as EventClass<unknown>);
if (!entry) {
throw new Error(`Unregistered Event class ${Event.name}`);
}
@@ -579,7 +611,9 @@ export class Link {
this._eventSnoopers.set(Event, handler);
}
static register(Class: typeof libData.Request | typeof libData.Event) {
static register<Req, Res>(Class: RequestClass<Req, Res>): void;
static register<T>(Class: EventClass<T>): void;
static register(Class: RequestClass<unknown, unknown> | EventClass<unknown>) {
if (Class.type === "request") {
this.registerRequest(Class);
} else if (Class.type === "event") {
@@ -589,7 +623,7 @@ export class Link {
}
}
static requestFromJSON(Request: typeof libData.Request, name: string) {
static requestFromJSON<Req, Res>(Request: RequestClass<Req, Res>, name: string): (json: any) => Request<Req, Res> {
if (Request.fromJSON) {
if (!Request.jsonSchema) {
throw new Error(`Request ${name} has static fromJSON but is missing static jsonSchema`);
@@ -599,7 +633,7 @@ export class Link {
if (!validate(json)) {
throw new libErrors.InvalidMessage(`Request ${name} failed validation`, validate.errors);
}
return Request.fromJSON(json);
return Request.fromJSON!(json);
};
}
if (Request.jsonSchema) {
@@ -608,7 +642,7 @@ export class Link {
return () => new Request();
}
static responseFromJSON(Response: libData.Serialisable, name: string) {
static responseFromJSON<T>(Response: JSONDeserialisable<T>, name: string) {
if (!Response.jsonSchema) {
throw new Error(`Response for Request ${name} is missing static jsonSchema`);
}
@@ -627,7 +661,11 @@ export class Link {
};
}
static allowedTypes(types: libData.AddressType | libData.AddressType[], name: string, side: "src" | "dst") {
static allowedTypes(
types: libData.AddressType | readonly libData.AddressType[],
name: string,
side: "src" | "dst"
) {
if (types === undefined) {
throw new Error(`Missing ${side} specification in ${name}`);
}
@@ -651,9 +689,9 @@ export class Link {
}
static _requestsByName = new Map<string, RequestEntry>();
static _requestsByClass = new Map<typeof libData.Request, RequestEntry>();
static _requestsByClass = new Map<RequestClass<unknown, unknown>, RequestEntry>();
static registerRequest(Request: typeof libData.Request) {
static registerRequest(Request: RequestClass<unknown, unknown>) {
const name = Request.plugin ? `${Request.plugin}:${Request.name}` : Request.name;
if (this._requestsByName.has(name)) {
throw new Error(`Request ${name} is already registered`);
@@ -685,7 +723,7 @@ export class Link {
this._requestsByClass.set(Request, entry);
}
static eventFromJSON(Event: typeof libData.Event, name: string) {
static eventFromJSON<T>(Event: EventClass<T>, name: string) {
if (Event.fromJSON) {
if (!Event.jsonSchema) {
throw new Error(`Event ${name} has static fromJSON but is missing static jsonSchema`);
@@ -695,7 +733,7 @@ export class Link {
if (!validate(json)) {
throw new libErrors.InvalidMessage(`Event ${name} failed validation`, validate.errors);
}
return Event.fromJSON(json);
return Event.fromJSON!(json);
};
}
if (Event.jsonSchema) {
@@ -705,16 +743,16 @@ export class Link {
}
static _eventsByName = new Map<string, EventEntry>();
static _eventsByClass = new Map<typeof libData.Event, EventEntry>();
static _eventsByClass = new Map<EventClass<unknown>, EventEntry>();
static registerEvent(Event: typeof libData.Event) {
static registerEvent<T>(Event: EventClass<T>) {
const name = Event.plugin ? `${Event.plugin}:${Event.name}` : Event.name;
if (this._eventsByName.has(name)) {
throw new Error(`Event ${name} is already registered`);
}
let entry = {
Event,
let entry: EventEntry = {
Event: Event as EventClass<unknown>,
name,
eventFromJSON: this.eventFromJSON(Event, name),
allowedSrcTypes: this.allowedTypes(Event.src, name, "src"),
@@ -729,13 +767,12 @@ export class Link {
}
this._eventsByName.set(name, entry);
this._eventsByClass.set(Event, entry);
this._eventsByClass.set(Event as EventClass<unknown>, entry);
}
}
for (let Class of dataClasses) {
// @ts-ignore: TODO Remove when lib/data is migrated to ts
Link.register(Class);
Link.register(Class as RequestClass<unknown, unknown>);
}
export function registerPluginMessages(pluginInfos: PluginInfo[]) {
+2 -1
View File
@@ -5,6 +5,7 @@ import * as host from "../data/messages_host";
import * as instance from "../data/messages_instance";
import * as mod from "../data/messages_mod";
import * as user from "../data/messages_user";
import type { RequestClass, EventClass } from "./link";
/**
* Event and Request payloads registered with the Link class. Used to decode
@@ -12,7 +13,7 @@ import * as user from "../data/messages_user";
* their proper classes.
* @internal
*/
export const dataClasses = [
export const dataClasses: (RequestClass<unknown, unknown> | EventClass<unknown>)[] = [
core.PingRequest,
controller.ControllerConfigGetRequest,