@google-cloud/agones-sdk 1.55.0 → 1.56.0

package/spec/support/jasmine.json

@@ -1,8 +1,6 @@
-{
-  "random": false,
-  "spec_dir": "spec",
-  "spec_files": [
-    "**/*.spec.js"
-  ],
-  "stopSpecOnExpectationFailure": true
-}
+{
+	"random": false,
+	"spec_dir": "spec",
+	"spec_files": ["**/*.spec.js"],
+	"stopSpecOnExpectationFailure": true
+}

package/src/agonesSDK.d.ts

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-import Alpha from './alpha';
+import Alpha from "./alpha";
 
 type Seconds = number;
 
@@ -38,13 +38,13 @@ type GameServer = {
 	};
 	status: {
 		state:
-		| 'Scheduled'
-		| 'Reserved'
-		| 'RequestReady'
-		| 'Ready'
-		| 'Shutdown'
-		| 'Allocated'
-		| 'Unhealthy';
+			| "Scheduled"
+			| "Reserved"
+			| "RequestReady"
+			| "Ready"
+			| "Shutdown"
+			| "Allocated"
+			| "Unhealthy";
 		address: string;
 		portsList: {
 			name: string;
@@ -56,31 +56,34 @@ type GameServer = {
 export declare class AgonesSDK {
 	constructor();
 
-	alpha: Alpha
+	alpha: Alpha;
 
-	get port(): string
+	get port(): string;
 
-	connect(): Promise<void>
+	connect(): Promise<void>;
 
-	close(): void
+	close(): void;
 
-	ready(): Promise<Record<string, any>>
+	ready(): Promise<Record<string, unknown>>;
 
-	allocate(): Promise<Record<string, any>>
+	allocate(): Promise<Record<string, unknown>>;
 
-	shutdown(): Promise<Record<string, any>>
+	shutdown(): Promise<Record<string, unknown>>;
 
-	health(errorCallback: (error: any) => any): void
+	health(errorCallback: (error: unknown) => void): void;
 
-	getGameServer(): Promise<GameServer>
+	getGameServer(): Promise<GameServer>;
 
-	watchGameServer(callback: (gameServer: GameServer) => any, errorCallback: (error: any) => any): void
+	watchGameServer(
+		callback: (gameServer: GameServer) => void,
+		errorCallback: (error: unknown) => void,
+	): void;
 
-	setLabel(key: string, value: string): Promise<Record<string, any>>
+	setLabel(key: string, value: string): Promise<Record<string, unknown>>;
 
-	setAnnotation(key: string, value: string): Promise<Record<string, any>>
+	setAnnotation(key: string, value: string): Promise<Record<string, unknown>>;
 
-	reserve(duration: Seconds): Promise<Record<string, any>>
+	reserve(duration: Seconds): Promise<Record<string, unknown>>;
 }
 
-export default AgonesSDK
+export default AgonesSDK;

package/src/agonesSDK.js

@@ -12,13 +12,13 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-const grpc = require('@grpc/grpc-js');
+const grpc = require("@grpc/grpc-js");
 
-const Alpha = require('./alpha');
-const Beta = require('./beta');
+const Alpha = require("./alpha");
+const Beta = require("./beta");
 
-const messages = require('../lib/sdk_pb');
-const servicesPackageDefinition = require('../lib/sdk_grpc_pb');
+const messages = require("../lib/sdk_pb");
+const servicesPackageDefinition = require("../lib/sdk_grpc_pb");
 
 class AgonesSDK {
 	constructor() {
@@ -33,7 +33,7 @@ class AgonesSDK {
 	}
 
 	get port() {
-		return process.env.AGONES_SDK_GRPC_PORT || '9357';
+		return process.env.AGONES_SDK_GRPC_PORT || "9357";
 	}
 
 	async connect() {
@@ -52,7 +52,9 @@ class AgonesSDK {
 		if (this.healthStream !== undefined) {
 			this.healthStream.end();
 		}
-		this.streams.forEach(stream => stream.destroy());
+		for (const stream of this.streams) {
+			stream.destroy();
+		}
 		this.client.close();
 	}
 
@@ -68,7 +70,7 @@ class AgonesSDK {
 			});
 		});
 	}
-	
+
 	async allocate() {
 		const request = new messages.Empty();
 		return new Promise((resolve, reject) => {
@@ -100,7 +102,7 @@ class AgonesSDK {
 			this.healthStream = this.client.health(() => {
 				// Ignore error as this can't be caught
 			});
-			this.healthStream.on('error', () => {
+			this.healthStream.on("error", () => {
 				// ignore error, prevent from being uncaught
 			});
 		}
@@ -132,11 +134,11 @@ class AgonesSDK {
 	watchGameServer(callback, errorCallback) {
 		const request = new messages.Empty();
 		const stream = this.client.watchGameServer(request);
-		stream.on('data', (data) => {
+		stream.on("data", (data) => {
 			callback(data.toObject());
 		});
 		if (errorCallback) {
-			stream.on('error', (error) => {
+			stream.on("error", (error) => {
 				errorCallback(error);
 			});
 		}

package/src/alpha.d.ts

@@ -15,19 +15,19 @@
 type PlayerId = string;
 
 declare class Alpha {
-	playerConnect(playerID: PlayerId): Promise<boolean>
+	playerConnect(playerID: PlayerId): Promise<boolean>;
 
-	playerDisconnect(playerID: PlayerId): Promise<boolean>
+	playerDisconnect(playerID: PlayerId): Promise<boolean>;
 
-	setPlayerCapacity(capacity: number): Promise<Record<string, any>>
+	setPlayerCapacity(capacity: number): Promise<Record<string, unknown>>;
 
-	getPlayerCapacity(): Promise<number>
+	getPlayerCapacity(): Promise<number>;
 
-	getPlayerCount(): Promise<number>
+	getPlayerCount(): Promise<number>;
 
-	isPlayerConnected(playerID: PlayerId): Promise<boolean>
+	isPlayerConnected(playerID: PlayerId): Promise<boolean>;
 
-	getConnectedPlayers(): Promise<PlayerId[]>
+	getConnectedPlayers(): Promise<PlayerId[]>;
 }
 
 export default Alpha;

package/src/alpha.js

@@ -1,130 +1,130 @@
-// Copyright 2020 Google LLC All Rights Reserved.
-
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-const grpc = require('@grpc/grpc-js');
-
-const messages = require('../lib/alpha/alpha_pb');
-const servicesPackageDefinition = require('../lib/alpha/alpha_grpc_pb');
-
-class Alpha {
-	constructor(address, credentials) {
-		const services = grpc.loadPackageDefinition(servicesPackageDefinition);
-		this.client = new services.agones.dev.sdk.alpha.SDK(address, credentials);
-	}
-
-	async playerConnect(playerID) {
-		const request = new messages.PlayerID();
-		request.setPlayerid(playerID);
-
-		return new Promise((resolve, reject) => {
-			this.client.playerConnect(request, (error, response) => {
-				if (error) {
-					reject(error);
-				} else {
-					resolve(response.getBool());
-				}
-			});
-		});
-	}
-
-	async playerDisconnect(playerID) {
-		const request = new messages.PlayerID();
-		request.setPlayerid(playerID);
-
-		return new Promise((resolve, reject) => {
-			this.client.playerDisconnect(request, (error, response) => {
-				if (error) {
-					reject(error);
-				} else {
-					resolve(response.getBool());
-				}
-			});
-		});
-	}
-
-	async setPlayerCapacity(capacity) {
-		const request = new messages.Count();
-		request.setCount(capacity);
-
-		return new Promise((resolve, reject) => {
-			this.client.setPlayerCapacity(request, (error, response) => {
-				if (error) {
-					reject(error);
-				} else {
-					resolve(response.toObject());
-				}
-			});
-		});
-	}
-
-	async getPlayerCapacity() {
-		const request = new messages.Empty();
-
-		return new Promise((resolve, reject) => {
-			this.client.getPlayerCapacity(request, (error, response) => {
-				if (error) {
-					reject(error);
-				} else {
-					resolve(response.getCount());
-				}
-			});
-		});
-	}
-
-	async getPlayerCount() {
-		const request = new messages.Empty();
-
-		return new Promise((resolve, reject) => {
-			this.client.getPlayerCount(request, (error, response) => {
-				if (error) {
-					reject(error);
-				} else {
-					resolve(response.getCount());
-				}
-			});
-		});
-	}
-
-	async isPlayerConnected(playerID) {
-		const request = new messages.PlayerID();
-		request.setPlayerid(playerID);
-
-		return new Promise((resolve, reject) => {
-			this.client.isPlayerConnected(request, (error, response) => {
-				if (error) {
-					reject(error);
-				} else {
-					resolve(response.getBool());
-				}
-			});
-		});
-	}
-
-	async getConnectedPlayers() {
-		const request = new messages.Empty();
-
-		return new Promise((resolve, reject) => {
-			this.client.getConnectedPlayers(request, (error, response) => {
-				if (error) {
-					reject(error);
-				} else {
-					resolve(response.getListList());
-				}
-			});
-		});
-	}
-}
-
-module.exports = Alpha;
+// Copyright 2020 Google LLC All Rights Reserved.
+
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+const grpc = require("@grpc/grpc-js");
+
+const messages = require("../lib/alpha/alpha_pb");
+const servicesPackageDefinition = require("../lib/alpha/alpha_grpc_pb");
+
+class Alpha {
+	constructor(address, credentials) {
+		const services = grpc.loadPackageDefinition(servicesPackageDefinition);
+		this.client = new services.agones.dev.sdk.alpha.SDK(address, credentials);
+	}
+
+	async playerConnect(playerID) {
+		const request = new messages.PlayerID();
+		request.setPlayerid(playerID);
+
+		return new Promise((resolve, reject) => {
+			this.client.playerConnect(request, (error, response) => {
+				if (error) {
+					reject(error);
+				} else {
+					resolve(response.getBool());
+				}
+			});
+		});
+	}
+
+	async playerDisconnect(playerID) {
+		const request = new messages.PlayerID();
+		request.setPlayerid(playerID);
+
+		return new Promise((resolve, reject) => {
+			this.client.playerDisconnect(request, (error, response) => {
+				if (error) {
+					reject(error);
+				} else {
+					resolve(response.getBool());
+				}
+			});
+		});
+	}
+
+	async setPlayerCapacity(capacity) {
+		const request = new messages.Count();
+		request.setCount(capacity);
+
+		return new Promise((resolve, reject) => {
+			this.client.setPlayerCapacity(request, (error, response) => {
+				if (error) {
+					reject(error);
+				} else {
+					resolve(response.toObject());
+				}
+			});
+		});
+	}
+
+	async getPlayerCapacity() {
+		const request = new messages.Empty();
+
+		return new Promise((resolve, reject) => {
+			this.client.getPlayerCapacity(request, (error, response) => {
+				if (error) {
+					reject(error);
+				} else {
+					resolve(response.getCount());
+				}
+			});
+		});
+	}
+
+	async getPlayerCount() {
+		const request = new messages.Empty();
+
+		return new Promise((resolve, reject) => {
+			this.client.getPlayerCount(request, (error, response) => {
+				if (error) {
+					reject(error);
+				} else {
+					resolve(response.getCount());
+				}
+			});
+		});
+	}
+
+	async isPlayerConnected(playerID) {
+		const request = new messages.PlayerID();
+		request.setPlayerid(playerID);
+
+		return new Promise((resolve, reject) => {
+			this.client.isPlayerConnected(request, (error, response) => {
+				if (error) {
+					reject(error);
+				} else {
+					resolve(response.getBool());
+				}
+			});
+		});
+	}
+
+	async getConnectedPlayers() {
+		const request = new messages.Empty();
+
+		return new Promise((resolve, reject) => {
+			this.client.getConnectedPlayers(request, (error, response) => {
+				if (error) {
+					reject(error);
+				} else {
+					resolve(response.getListList());
+				}
+			});
+		});
+	}
+}
+
+module.exports = Alpha;

package/src/beta.d.ts

@@ -13,31 +13,31 @@
 // limitations under the License.
 
 declare class Beta {
-	getCounterCount(key: string): Promise<number>
+	getCounterCount(key: string): Promise<number>;
 
-	incrementCounter(key: string, amount: number): Promise<void>
+	incrementCounter(key: string, amount: number): Promise<void>;
 
-	decrementCounter(key: string, amount: number): Promise<void>
+	decrementCounter(key: string, amount: number): Promise<void>;
 
-	setCounterCount(key: string, amount: number): Promise<void>
+	setCounterCount(key: string, amount: number): Promise<void>;
 
-	getCounterCapacity(key: string): Promise<number>
+	getCounterCapacity(key: string): Promise<number>;
 
-	setCounterCapacity(key: string, amount: number): Promise<void>
+	setCounterCapacity(key: string, amount: number): Promise<void>;
 
-	getListCapacity(key: string): Promise<number>
+	getListCapacity(key: string): Promise<number>;
 
-	setListCapacity(key: string, amount: number): Promise<void>
+	setListCapacity(key: string, amount: number): Promise<void>;
 
-	listContains(key: string, value: string): Promise<boolean>
+	listContains(key: string, value: string): Promise<boolean>;
 
-	getListLength(key: string): Promise<number>
+	getListLength(key: string): Promise<number>;
 
-	getListValues(key: string): Promise<string[]>
+	getListValues(key: string): Promise<string[]>;
 
-	appendListValue(key: string, value: string): Promise<void>
+	appendListValue(key: string, value: string): Promise<void>;
 
-	deleteListValue(key:string , value: string): Promise<void>
+	deleteListValue(key: string, value: string): Promise<void>;
 }
 
 export default Beta;