bedrock-portal 0.1.2 → 0.2.0

package/.eslintrc.json

@@ -5,14 +5,15 @@
 		"es2022": true
 	},
 	"rules": {
-        "brace-style": ["error", "stroustrup", { "allowSingleLine": true }],
+		"eol-last": ["error", "always"],
+		"brace-style": ["error", "stroustrup", { "allowSingleLine": true }],
 		"comma-dangle": ["error", "always-multiline"],
 		"comma-spacing": "error",
 		"comma-style": "error",
 		"curly": ["error", "multi-line", "consistent"],
 		"dot-location": ["error", "property"],
 		"handle-callback-err": "off",
-		"indent": ["error", "tab", { "SwitchCase": 1 }],
+		"indent": ["error", 2, { "SwitchCase": 1 }],
 		"max-nested-callbacks": ["error", { "max": 4 }],
 		"max-statements-per-line": ["error", { "max": 2 }],
 		"no-console": "off",

package/.github/workflows/ci.yml

@@ -0,0 +1,30 @@
+name: CI
+
+on:
+  push:
+    branches: ['*']
+  pull_request:
+    branches: ['*']
+  workflow_dispatch:
+    inputs:
+      via:
+          description: 'trigger origin'
+          required: true
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+        node-version: [16.x]
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 12
+    steps:
+    - uses: actions/checkout@v2
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v1
+      with:
+        node-version: ${{ matrix.node-version }}
+    - run: npm install
+    - run: npm run lint

package/README.md

@@ -14,40 +14,39 @@ This package is not meant to be used with your main account. It is meant to be u
 
 ## Usage
 
-### BedrockPortal(authflow)
+### BedrockPortal(authflow, options)
 **Parameters**
 - authflow - Takes an **Authflow** instance from [prismarine-auth](https://github.com/PrismarineJS/prismarine-auth), you can see the documentation for this [here.](https://github.com/PrismarineJS/prismarine-auth#authflow)
 - options
-  - **ip** - The IP address of the server to redirect players to
-  - **port** - The port of the server to redirect players to
-  - **disableAltCheck** - Disables the alt check.
-  - **joinability** - The joinability of the session, Can be 'friends_of_friends', 'friends_only', 'invite_only'
+  - **ip** - The IP address of the server to redirect players to (required)
+  - **port** - The port of the server to redirect players to (default: 19132)
+  - **disableAltCheck** - Disables the alt check (default: false)
+  - **joinability** - The joinability of the session (default: Joinability.FriendsOfFriends)
   - **world** - The world config to use for the session. Changes the session card which is displayed in the Minecraft client.
-	  - **hostName** - string
-	  - **name** - string
-	  - **version** - string
-	  - **memberCount** - number
-	  - **maxMemberCount** - number
-  - **modules** - An object containing modules to enable. See [Modules](#modules) for more information.
+	  - **hostName** - string (default: '{gamertag}'s Portal')
+	  - **name** - string (default: 'BedrockPortal')
+	  - **version** - string (default: '{BedrockPortal version}')
+	  - **memberCount** - number (default: 0)
+	  - **maxMemberCount** - number (default: 10)
 
 ### Create a session redirect to a server
 ```js
-const { BedrockPortal } = require('bedrock-portal');
+const { BedrockPortal, Joinability } = require('bedrock-portal');
 const { Authflow, Titles } = require('prismarine-auth');
 
 const main = async () => {
-  const auth = new Authflow('example', './', { authTitle: Titles.MinecraftNintendoSwitch, deviceType: 'Nintendo' });
+  const auth = new Authflow('example', './', { authTitle: Titles.MinecraftNintendoSwitch, deviceType: 'Nintendo', flow: 'live' });
   
-  const session = new BedrockPortal(auth, {
+  const portal = new BedrockPortal(auth, {
     ip: 'geyserconnect.net', // The server IP & port to redirect players to
     port: 19132,
-    joinability: 'friends_of_friends', // The joinability of the session. Can be 'friends_of_friends', 'friends_only', 'invite_only'
+    joinability: Joinability.InviteOnly, // The joinability of the session. Joinability.FriendsOfFriends, Joinability.FriendsOnly, Joinability.InviteOnly
   });
 
-  await session.start();
+  await portal.start();
 	
   // accepts a player's gamertag or xuid
-  await session.invitePlayer('p3')
+  await portal.invitePlayer('p3')
 
 };
 
@@ -56,26 +55,213 @@ main();
 
 ## Modules
 
-Modules are used to extend the functionality of the BedrockPortal class. You can find a list of modules below.
+Modules are used to extend the functionality of the BedrockPortal class.
+
+### autoFriendAdd
+
+Automatically adds the account's followers as friends and invites them to the game. `#.use(Modules.autoFriendAdd);`
+
+Options:
+- **autoInvite**: boolean - Automatically invites recently added friends to the game (default: false)
 
 ```js
-new BedrockPortal(auth, {
-  ...,
-  modules: {
-    autoFriendAdd: true, // Automatically add friends to the session
-  },
-})
+const { Modules } = require('bedrock-portal');
+
+const portal = new BedrockPortal(auth, { ... })
+
+portal.use(Modules.autoFriendAdd);
+
+// or
+
+portal.use(Modules.autoFriendAdd, {
+  autoInvite: true,
+});
 ```
 
-### autoFriendAdd
+## Modules API
+
+Creating a module is easy. You can create a module by extending the `Module` class.
+
+Note: The `stopped` property is set to `true` when the module is stopped. You can use this to stop the module's loop (if one is present) else the process will not exit.
+
+```js
+const { Module } = require('bedrock-portal');
+
+const myModule = class MyModule extends Module {
+  constructor() {
+    super('myModule', 'Description of my module');
+    this.options = {
+      option1: true,
+    }
+  }
+
+  async run(portal, { rest, rta }) {
+    // portal - The BedrockPortal instance
+    // rest - The REST API instance
+    // rta - The RTA API instance
+
+    // Do stuff here
+  }
+}
+
+portal.use(myModule);
+```
+
+## Events
+
+### portal.on('sessionCreated', (session) => {})
+Emitted when a session is created.
+
+**Parameters**
+- session - [Session](#session) object
+
 
-Automatically adds the account's followers as friends so the session can be joined by them.
-* Add `autoFriendAdd: true` to the modules object in the BedrockPortal constructor.
+### portal.on('sessionUpdated', (session) => {})
+Emitted when a session is updated.
+
+**Parameters**
+- session - [Session](#session) object
+
+
+### portal.on('playerJoin', (player) => {})
+Emitted when a player joins the session.
+
+**Parameters**
+- player - [Player](#player) object
+
+
+### portal.on('playerLeave', (player) => {})
+Emitted when a player leaves the session.
+
+**Parameters**
+- player - [Player](#player) object
+
+
+### portal.on('friendAdded', (player) => {})
+Emitted when a player is added as a friend. This event is only emitted when the `autoFriendAdd` module is enabled.
+
+**Parameters**
+- player - [Player](#player) object
+
+## Objects
+
+### Player
+
+```ts
+{
+  profile?: {
+    xuid: string,
+    avatar: string,
+    gamerscore: string,
+    gamertag: string,
+    tier: string,
+    reputation: string,
+    colour: {
+      primaryColour: string,
+      secondaryColour: string,
+      tertiaryColour: string
+    },
+    realname: string,
+    bio: string,
+    location: string,
+    modernGamertag: string,
+    modernGamertagSuffix: string,
+    uniqueModernGamertag: string,
+    realnameOverride: string,
+    tenureLevel: string,
+    watermarks: string,
+    isQuarantined: boolean,
+    linkedAccounts: []
+  }
+  session?: {
+    titleId: string
+    joinTime: string
+    index: number
+    connectionId: string
+    subscriptionId: string
+  }
+}
+```
+
+### Session
+
+```ts
+{
+  membersInfo: {
+    first: number,
+    next: number,
+    count: number,
+    accepted: number,
+    active: number
+  },
+  constants: {
+    system: {
+      readyRemovalTimeout: number,
+      reservedRemovalTimeout: number,
+      sessionEmptyTimeout: number,
+      inactiveRemovalTimeout: number,
+      version: number,
+      maxMembersCount: number,
+      visibility: string,
+      capabilities: {
+        connectivity: boolean,
+        connectionRequiredForActiveMembers: boolean,
+        gameplay: boolean,
+        crossPlay: boolean,
+        userAuthorizationStyle: boolean
+      },
+      inviteProtocol: string,
+      memberInitialization: {
+        membersNeededToStart: number,
+      }
+    },
+    custom: {}
+  },
+  properties: {
+    system: {
+      joinRestriction: 'followed' | 'local',
+      readRestriction: string,
+      turn: []
+    },
+    custom: {
+      Joinability: string,
+      hostName: string,
+      ownerId: string,
+      rakNetGUID: string,
+      version: string,
+      worldName: string,
+      worldType: string,
+      protocol: number,
+      MemberCount: number,
+      MaxMemberCount: number,
+      BroadcastSetting: number,
+      UsesWebSocketsWebRTCSignaling: boolean,
+      UsesMPSDWebRTCSignaling: boolean,
+      netherNetEnabled: boolean,
+      OnlineCrossPlatformGame: boolean,
+      CrossPlayDisabled: boolean,
+      TitleId: number,
+      SupportedConnections: SessionConnection[],
+      levelId: string,
+      LanGame: boolean
+    }
+  },
+  servers: {},
+  members: {
+    [index: number]: SessionMember
+  }
+  correlationId: string,
+  contractVersion: number,
+  branch: string,
+  changeNumber: number,
+  startTime: string
+}
+```
 
 
 ## Debugging
 
-You can enable some debugging output using the `DEBUG` enviroment variable. Through node.js, you can add `process.env.DEBUG = 'bedrock-portal'` at the top of your code.
+You can enable some debugging output using the `DEBUG` enviroment variable. Through node.js, you can add `process.env.DEBUG = 'bedrock-portal*'` at the top of your code.
 
 ## License
 

package/examples/portal.js

@@ -0,0 +1,56 @@
+/* eslint-disable no-multi-spaces */
+const { BedrockPortal, Modules, Joinability } = require('bedrock-portal');
+const { Authflow, Titles } = require('prismarine-auth');
+
+const main = async () => {
+  const auth = new Authflow('example', './', { authTitle: Titles.MinecraftNintendoSwitch, deviceType: 'Nintendo', flow: 'live' });
+
+  const portal = new BedrockPortal(auth, {
+    ip: 'geyserconnect.net',
+    port: 19132,                               // The port of the server (optional - defaults to 19132)
+    joinability: Joinability.FriendsOfFriends, // The joinability of the session (optional - defaults to Joinability.FriendsOfFriends)
+    disableAltCheck: false,                    // Disables the alt check (optional - defaults to false)
+    world: {                                   // Only affects the join world card in the friends list (optional)
+      hostName: 'BedrockPortal',               // Displays as the host name of the world
+      name: 'BedrockPortal',                   // Displays as the name of the world
+      version: '1',                            // Displays as the version of the world
+      memberCount: 0,                          // The current member count of the world
+      maxMemberCount: 10,                      // The max member count of the world
+    },
+  });
+
+  portal.use(Modules.autoFriendAdd, {          // Automatically adds friends to the session
+    inviteOnAdd: true,
+  });
+
+  await portal.start();                        // Starts the session
+
+  await portal.invitePlayer('p3');             // gamertag or xuid to invite
+
+  portal.on('rtaEvent', (event) => {           // Emits when an RTA event is received
+    console.log('RTA Event: ', event);
+  });
+
+  portal.on('sessionCreated', (session) => {   // Emits when the session is created'
+    console.log('Session Created: ', session);
+  });
+
+  portal.on('sessionUpdated', (session) => {   // Emits when the session is updated
+    console.log('Session Updated: ', session);
+  });
+
+  portal.on('playerJoin', (player) => {        // Emits when a player joins the session
+    console.log('Player Join: ', player);
+  });
+
+  portal.on('playerLeave', (player) => {       // Emits when a player leaves the session
+    console.log('Player Leave: ', player);
+  });
+
+  portal.on('friendAdded', (player) => {       // Emits when a friend is added. Only emitted if autoFriendAdd module is used
+    console.log('Friend Added: ', player);
+  });
+
+};
+
+main();