@antha/multiplayer-core 0.14.1 → 0.14.2

package/dist/multiplayer-api/multiplayer-controller.d.ts

@@ -89,7 +89,7 @@ export type MultiplayerRoomControllerParams<Message extends JsonCompatibleValue>
      *
      * @default accept all connections
      */
-    acceptConnection?: ((connectingClientId: ClientId, controller: MultiplayerRoomController<Message>) => MaybePromise<boolean>) | undefined;
+    acceptConnection?: ((connectingClientId: ClientId, multiplayerController: MultiplayerRoomController<Message>) => MaybePromise<boolean>) | undefined;
 }>;
 /**
  * Multiplayer mode parameters for {@link MultiplayerRoomController}.
@@ -129,30 +129,30 @@ export type MultiplayerInitParams = {
     /** If set, this will override the internal multiplayer API. */
     multiplayerApiClient: Readonly<MultiplayerApiClient>;
 }>;
-declare const ControllerMessageEvent_base: (new (eventInitDict: {
+declare const MultiplayerControllerMessageEvent_base: (new (eventInitDict: {
     bubbles?: boolean;
     cancelable?: boolean;
     composed?: boolean;
     detail: any;
-}) => import("typed-event-target").TypedCustomEvent<any, "controller-message">) & Pick<{
+}) => import("typed-event-target").TypedCustomEvent<any, "multiplayer-controller-message">) & Pick<{
     new (type: string, eventInitDict?: EventInit): Event;
     prototype: Event;
     readonly NONE: 0;
     readonly CAPTURING_PHASE: 1;
     readonly AT_TARGET: 2;
     readonly BUBBLING_PHASE: 3;
-}, "prototype" | "NONE" | "CAPTURING_PHASE" | "AT_TARGET" | "BUBBLING_PHASE"> & Pick<import("typed-event-target").TypedCustomEvent<any, "controller-message">, "type">;
+}, "prototype" | "NONE" | "CAPTURING_PHASE" | "AT_TARGET" | "BUBBLING_PHASE"> & Pick<import("typed-event-target").TypedCustomEvent<any, "multiplayer-controller-message">, "type">;
 /**
  * This is fired when a room message is received.
  *
  * @category Events
  */
-export declare class ControllerMessageEvent<Message extends JsonCompatibleValue> extends ControllerMessageEvent_base {
+export declare class MultiplayerControllerMessageEvent<Message extends JsonCompatibleValue> extends MultiplayerControllerMessageEvent_base {
     readonly sourceClientId: ClientId;
     detail: Message;
     constructor(sourceClientId: ClientId, detail: Message);
 }
-declare const ControllerRoomListEvent_base: (new (eventInitDict: {
+declare const MultiplayerControllerRoomListEvent_base: (new (eventInitDict: {
     bubbles?: boolean;
     cancelable?: boolean;
     composed?: boolean;
@@ -167,7 +167,7 @@ declare const ControllerRoomListEvent_base: (new (eventInitDict: {
     roomName: string;
     clientCount: number;
     hasRoomPassword: boolean;
-}>>>, "controller-room-list">) & Pick<{
+}>>>, "multiplayer-controller-room-list">) & Pick<{
     new (type: string, eventInitDict?: EventInit): Event;
     prototype: Event;
     readonly NONE: 0;
@@ -179,7 +179,7 @@ declare const ControllerRoomListEvent_base: (new (eventInitDict: {
     roomName: string;
     clientCount: number;
     hasRoomPassword: boolean;
-}>>>, "controller-room-list">, "type">;
+}>>>, "multiplayer-controller-room-list">, "type">;
 /**
  * This is called whenever the room list updates, even if there were no changes to the room list. By
  * default, room list updates are off. Use `MultiplayerRoomController.startRoomUpdates` to start
@@ -187,15 +187,15 @@ declare const ControllerRoomListEvent_base: (new (eventInitDict: {
  *
  * @category Events
  */
-export declare class ControllerRoomListEvent extends ControllerRoomListEvent_base {
+export declare class MultiplayerControllerRoomListEvent extends MultiplayerControllerRoomListEvent_base {
 }
 /**
  * Callback fired whenever the room list is fetched from the multiplayer API.
  *
  * @category Internal
  */
-export type ControllerRoomListListener = (rooms: Readonly<MultiplayerClientRooms>) => MaybePromise<void>;
-declare const ControllerClientEvent_base: (new (eventInitDict: {
+export type MultiplayerControllerRoomListListener = (rooms: Readonly<MultiplayerClientRooms>) => MaybePromise<void>;
+declare const MultiplayerControllerClientEvent_base: (new (eventInitDict: {
     bubbles?: boolean;
     cancelable?: boolean;
     composed?: boolean;
@@ -250,7 +250,7 @@ declare const ControllerClientEvent_base: (new (eventInitDict: {
     newMember: ClientId;
     lostHost: ClientId;
     lostMember: ClientId;
-}, "newHost" | "newMember" | "lostHost" | "lostMember">>, "controller-client">) & Pick<{
+}, "newHost" | "newMember" | "lostHost" | "lostMember">>, "multiplayer-controller-client">) & Pick<{
     new (type: string, eventInitDict?: EventInit): Event;
     prototype: Event;
     readonly NONE: 0;
@@ -282,7 +282,7 @@ declare const ControllerClientEvent_base: (new (eventInitDict: {
     newMember: ClientId;
     lostHost: ClientId;
     lostMember: ClientId;
-}, "newHost" | "newMember" | "lostHost" | "lostMember">>, "controller-client">, "type">;
+}, "newHost" | "newMember" | "lostHost" | "lostMember">>, "multiplayer-controller-client">, "type">;
 /**
  * This is fired in the following situations:
  *
@@ -293,34 +293,34 @@ declare const ControllerClientEvent_base: (new (eventInitDict: {
  *
  * @category Events
  */
-export declare class ControllerClientEvent extends ControllerClientEvent_base {
+export declare class MultiplayerControllerClientEvent extends MultiplayerControllerClientEvent_base {
 }
-declare const ControllerConnectionEvent_base: (new (eventInitDict: {
+declare const MultiplayerControllerConnectionEvent_base: (new (eventInitDict: {
     bubbles?: boolean;
     cancelable?: boolean;
     composed?: boolean;
     detail: ApiAndRoomConnectionState;
-}) => import("typed-event-target").TypedCustomEvent<ApiAndRoomConnectionState, "controller-connection">) & Pick<{
+}) => import("typed-event-target").TypedCustomEvent<ApiAndRoomConnectionState, "multiplayer-controller-connection">) & Pick<{
     new (type: string, eventInitDict?: EventInit): Event;
     prototype: Event;
     readonly NONE: 0;
     readonly CAPTURING_PHASE: 1;
     readonly AT_TARGET: 2;
     readonly BUBBLING_PHASE: 3;
-}, "prototype" | "NONE" | "CAPTURING_PHASE" | "AT_TARGET" | "BUBBLING_PHASE"> & Pick<import("typed-event-target").TypedCustomEvent<ApiAndRoomConnectionState, "controller-connection">, "type">;
+}, "prototype" | "NONE" | "CAPTURING_PHASE" | "AT_TARGET" | "BUBBLING_PHASE"> & Pick<import("typed-event-target").TypedCustomEvent<ApiAndRoomConnectionState, "multiplayer-controller-connection">, "type">;
 /**
  * Fires when the controller's connection state is updated.
  *
  * @category Events
  */
-export declare class ControllerConnectionEvent extends ControllerConnectionEvent_base {
+export declare class MultiplayerControllerConnectionEvent extends MultiplayerControllerConnectionEvent_base {
 }
 /**
  * All events emitted by this controller.
  *
  * @category Internal
  */
-export type AllMultiplayerRoomControllerEvents<Message extends JsonCompatibleValue> = ControllerMessageEvent<Message> | ControllerRoomListEvent | ControllerClientEvent | ControllerConnectionEvent;
+export type AllMultiplayerRoomControllerEvents<Message extends JsonCompatibleValue> = MultiplayerControllerMessageEvent<Message> | MultiplayerControllerRoomListEvent | MultiplayerControllerClientEvent | MultiplayerControllerConnectionEvent;
 /**
  * A generic multiplayer room controller. It manages API connectivity, room discovery, WebRTC
  * signaling, and generic room messages. It does not impose a game-state synchronization strategy.
@@ -331,17 +331,17 @@ export declare class MultiplayerRoomController<Message extends JsonCompatibleVal
     protected readonly params: MultiplayerRoomControllerParams<Message>;
     /** All events emitted by this controller. */
     static readonly events: {
-        ControllerMessageEvent: typeof ControllerMessageEvent;
-        ControllerRoomListEvent: typeof ControllerRoomListEvent;
-        ControllerClientEvent: typeof ControllerClientEvent;
-        ControllerConnectionEvent: typeof ControllerConnectionEvent;
+        MultiplayerControllerMessageEvent: typeof MultiplayerControllerMessageEvent;
+        MultiplayerControllerRoomListEvent: typeof MultiplayerControllerRoomListEvent;
+        MultiplayerControllerClientEvent: typeof MultiplayerControllerClientEvent;
+        MultiplayerControllerConnectionEvent: typeof MultiplayerControllerConnectionEvent;
     };
     /** All events emitted by this controller. */
     readonly events: {
-        ControllerMessageEvent: typeof ControllerMessageEvent;
-        ControllerRoomListEvent: typeof ControllerRoomListEvent;
-        ControllerClientEvent: typeof ControllerClientEvent;
-        ControllerConnectionEvent: typeof ControllerConnectionEvent;
+        MultiplayerControllerMessageEvent: typeof MultiplayerControllerMessageEvent;
+        MultiplayerControllerRoomListEvent: typeof MultiplayerControllerRoomListEvent;
+        MultiplayerControllerClientEvent: typeof MultiplayerControllerClientEvent;
+        MultiplayerControllerConnectionEvent: typeof MultiplayerControllerConnectionEvent;
     };
     static readonly knownErrors: {
         RoomRejectionError: typeof RoomRejectionError;
@@ -404,9 +404,9 @@ export declare class MultiplayerRoomController<Message extends JsonCompatibleVal
      *
      * If a callback is provided, it is called each time the room list is updated.
      */
-    startRoomUpdates(callback: ControllerRoomListListener): RemoveListenerCallback;
+    startRoomUpdates(callback: MultiplayerControllerRoomListListener): RemoveListenerCallback;
     startRoomUpdates(callback?: undefined): undefined;
-    startRoomUpdates(callback?: ControllerRoomListListener | undefined): RemoveListenerCallback | undefined;
+    startRoomUpdates(callback?: MultiplayerControllerRoomListListener | undefined): RemoveListenerCallback | undefined;
     /** Turn off room list updates and remove callbacks added via `startRoomUpdates`. */
     stopRoomUpdates(): void;
     /** Send a generic message to the current room. */

package/dist/multiplayer-api/multiplayer-controller.js

@@ -32,7 +32,7 @@ export const emptyApiAndRoomConnectionState = {
  *
  * @category Events
  */
-export class ControllerMessageEvent extends defineTypedCustomEvent()('controller-message') {
+export class MultiplayerControllerMessageEvent extends defineTypedCustomEvent()('multiplayer-controller-message') {
     sourceClientId;
     constructor(sourceClientId, detail) {
         super({
@@ -48,7 +48,7 @@ export class ControllerMessageEvent extends defineTypedCustomEvent()('controller
  *
  * @category Events
  */
-export class ControllerRoomListEvent extends defineTypedCustomEvent()('controller-room-list') {
+export class MultiplayerControllerRoomListEvent extends defineTypedCustomEvent()('multiplayer-controller-room-list') {
 }
 /**
  * This is fired in the following situations:
@@ -60,14 +60,14 @@ export class ControllerRoomListEvent extends defineTypedCustomEvent()('controlle
  *
  * @category Events
  */
-export class ControllerClientEvent extends defineTypedCustomEvent()('controller-client') {
+export class MultiplayerControllerClientEvent extends defineTypedCustomEvent()('multiplayer-controller-client') {
 }
 /**
  * Fires when the controller's connection state is updated.
  *
  * @category Events
  */
-export class ControllerConnectionEvent extends defineTypedCustomEvent()('controller-connection') {
+export class MultiplayerControllerConnectionEvent extends defineTypedCustomEvent()('multiplayer-controller-connection') {
 }
 /**
  * A generic multiplayer room controller. It manages API connectivity, room discovery, WebRTC
@@ -79,10 +79,10 @@ export class MultiplayerRoomController extends ListenTarget {
     params;
     /** All events emitted by this controller. */
     static events = {
-        ControllerMessageEvent,
-        ControllerRoomListEvent,
-        ControllerClientEvent,
-        ControllerConnectionEvent,
+        MultiplayerControllerMessageEvent,
+        MultiplayerControllerRoomListEvent,
+        MultiplayerControllerClientEvent,
+        MultiplayerControllerConnectionEvent,
     };
     /** All events emitted by this controller. */
     events = MultiplayerRoomController.events;
@@ -182,7 +182,7 @@ export class MultiplayerRoomController extends ListenTarget {
         this.isListeningToRoomUpdates = true;
         this.startRoomInterval();
         if (callback) {
-            return this.listen(ControllerRoomListEvent, async (event) => {
+            return this.listen(MultiplayerControllerRoomListEvent, async (event) => {
                 await callback(event.detail);
             });
         }
@@ -239,10 +239,10 @@ export class MultiplayerRoomController extends ListenTarget {
             }
             : undefined);
         currentConnection.listen((WebrtcMultiplayerMessageEvent), (event) => {
-            this.dispatch(new ControllerMessageEvent(event.sourceClientId, event.detail));
+            this.dispatch(new MultiplayerControllerMessageEvent(event.sourceClientId, event.detail));
         });
         currentConnection.listen(WebrtcMultiplayerConnectionUpdateEvent, (event) => {
-            this.dispatch(new ControllerClientEvent({
+            this.dispatch(new MultiplayerControllerClientEvent({
                 detail: event.detail,
             }));
         });
@@ -311,7 +311,7 @@ export class MultiplayerRoomController extends ListenTarget {
         if (state.room) {
             makeWritable(this).roomConnectionState = state.room;
         }
-        this.dispatch(new ControllerConnectionEvent({
+        this.dispatch(new MultiplayerControllerConnectionEvent({
             detail: {
                 room: this.roomConnectionState,
                 api: this.apiConnectionState,
@@ -342,7 +342,7 @@ export class MultiplayerRoomController extends ListenTarget {
                     },
                 });
                 if (output.Ok) {
-                    this.dispatch(new ControllerRoomListEvent({
+                    this.dispatch(new MultiplayerControllerRoomListEvent({
                         detail: output.Ok.responseData,
                     }));
                 }

package/dist/webrtc/webrtc-multiplayer-controller.d.ts

@@ -156,9 +156,9 @@ export type RoomInput = Pick<Extract<MultiplayerConnectClientMessage, {
  *
  * @category Internal
  */
-export type ShouldAllowConnectionCheck<Controller> = (data: {
+export type ShouldAllowConnectionCheck<MultiplayerController> = (data: {
     connectingClientId: ClientId;
-    controller: Controller;
+    multiplayerController: MultiplayerController;
 }) => MaybePromise<boolean>;
 /**
  * A controller that connects to the multiplayer api and establishes a WebRTC connection to the

package/dist/webrtc/webrtc-multiplayer-controller.js

@@ -306,7 +306,7 @@ export class WebrtcMultiplayerController extends ListenTarget {
                             await this.connectionQueue.add(async () => {
                                 if (!this.shouldAllowConnectionCheck({
                                     connectingClientId: message.clientId,
-                                    controller: this,
+                                    multiplayerController: this,
                                 })) {
                                     log.warning('offer rejected');
                                     webSocket.send({

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@antha/multiplayer-core",
-    "version": "0.14.1",
+    "version": "0.14.2",
     "description": "Core functionalities for Antha multiplayer mods.",
     "keywords": [
         "vir",