@sanctumterra/raknet 1.0.17 → 1.0.18

package/.github/workflows/publish.yml

@@ -0,0 +1,24 @@
+name: Publish to to npm
+
+on:
+  push:
+    branches: v2
+
+jobs:
+  build:
+    permissions:
+      id-token: write
+      contents: read
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20.x'
+          registry-url: 'https://registry.npmjs.org'
+      - run: npm install
+      - run: npm run build
+      - run: npm publish --access=public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+ 

package/README.md

@@ -0,0 +1,15 @@
+# raknet
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run index.ts
+```
+
+This project was created using `bun init` in bun v1.1.27. [Bun](https://bun.sh) is a fast all-in-one JavaScript runtime.

package/dist/index.d.ts

@@ -1,13 +1,158 @@
-import "reflect-metadata";
-import { FrameHandler } from "./src/client/FrameHandler";
-import { PacketHandler } from "./src/client/PacketHandler";
-import { Queue } from "./src/client/Queue";
-import { Proto } from "./src/packets/proto";
-import { NewConnectionRequest } from "./src/packets/raknet/NewConnectionRequest";
-import { OhMyNewIncommingConnection } from "./src/packets/raknet/OhMyNewIncommingConnection";
-import { Serialize } from "./src/packets/serialize";
-import { Logger } from "./src/utils/Logger";
-import { RakNetClient } from "./src/client/RaknetClient";
-import { Advertisement } from "./src/client/RaknetClient";
-export { PacketHandler, FrameHandler, Queue, Proto, NewConnectionRequest, OhMyNewIncommingConnection, Serialize, Logger, RakNetClient, Advertisement };
-export default RakNetClient;
+import { BasePacket, Magic, Address, Frame, FrameSet, Priority, Status } from '@serenityjs/raknet';
+import EventEmitter from 'events';
+import dgram from 'dgram';
+
+declare class OpenFirstConnectionRequest extends BasePacket {
+    magic: Magic;
+    protocol: number;
+    mtu: number;
+}
+
+declare class UnconnectedPing extends BasePacket {
+    timestamp: bigint;
+    magic: Buffer;
+    client: bigint;
+}
+
+declare class OpenConnectionFirstReply extends BasePacket {
+    magic: Buffer;
+    guid: bigint;
+    security: boolean;
+    mtu: number;
+}
+
+declare class OpenConnectionSecondRequest extends BasePacket {
+    magic: Buffer;
+    address: Address;
+    mtu: number;
+    client: bigint;
+}
+
+declare class OpenConnectionSecondReply extends BasePacket {
+    magic: Buffer;
+    guid: bigint;
+    address: Address;
+    mtu: number;
+    encryption: boolean;
+}
+
+declare class ConnectionRequest extends BasePacket {
+    client: bigint;
+    timestamp: bigint;
+    security: boolean;
+}
+
+declare class ConnectionRequestAccepted extends BasePacket {
+    address: Address;
+    systemIndex: number;
+    systemAddresses: Address[];
+    requestTimestamp: bigint;
+    timestamp: bigint;
+}
+
+declare class NewIncomingConnection extends BasePacket {
+    serverAddress: Address;
+    internalAddresses: Address[];
+    incomingTimestamp: bigint;
+    serverTimestamp: bigint;
+}
+
+declare class ConnectedPing extends BasePacket {
+    timestamp: bigint;
+}
+
+declare class ConnectedPong extends BasePacket {
+    pingTime: bigint;
+    pongTime: bigint;
+}
+
+declare class Receiver {
+    private lastInputSequence;
+    private receivedFrameSequences;
+    private lostFrameSequences;
+    private inputHighestSequenceIndex;
+    private inputOrderIndex;
+    protected inputOrderingQueue: Map<number, Map<number, Frame>>;
+    protected readonly fragmentsQueue: Map<number, Map<number, Frame>>;
+    private raknet;
+    constructor(raknet: RakNetClient);
+    incomingMessage(buffer: Buffer): void;
+    otherPackets(buffer: Buffer): void;
+    handleOpenConnectionRequest2(buffer: Buffer): void;
+    handleOpenConnectionRequest(): void;
+    sendConnectionPacket(): void;
+    sendUnconnectedPing(): void;
+    private tick;
+    send(buffer: Buffer): void;
+    handleFrameSet(buffer: Buffer): void;
+    private handleFrame;
+    private processFrame;
+    private handleFragment;
+    private reassembleAndProcessFragment;
+    private handleSequenced;
+    private handleOrdered;
+    private processOrderedFrames;
+    private handleConnectedPing;
+    handleConnectionRequestAcceptedTwo(frame: Frame): NewIncomingConnection;
+    private handleConnectionRequestAccepted;
+}
+
+declare class Sender {
+    outputOrderIndex: Array<number>;
+    outputSequenceIndex: Array<number>;
+    outputFrameQueue: FrameSet;
+    mtu: number;
+    protected outputSequence: number;
+    protected outputsplitIndex: number;
+    protected outputReliableIndex: number;
+    protected outputFrames: Set<Frame>;
+    outputBackup: Map<number, Frame[]>;
+    protected client: RakNetClient;
+    constructor(client: RakNetClient);
+    onTick(): void;
+    /**
+     * Sends a frame to the connection.
+     *
+     * @param frame - The frame to send
+     * @param priority - The priority of the frame
+     */
+    sendFrame(frame: Frame, priority: Priority): void;
+    private queueFrame;
+    sendQueue(amount: number): void;
+}
+
+declare class RakNetClient extends EventEmitter {
+    socket: dgram.Socket;
+    private ticker;
+    receiver: Receiver;
+    sender: Sender;
+    private id;
+    private address;
+    private port;
+    status: Status;
+    protocol: number;
+    mtu: number;
+    debug: boolean;
+    constructor(protocol?: number, debug?: boolean);
+    connect(address: string, port: number): Promise<void>;
+    ping(): void;
+    close(): Promise<void>;
+    send(packet: Buffer): void;
+    getAddress(): Address;
+    getId(): bigint;
+}
+
+type VersionType = 'MCPE' | 'MCEE';
+interface Advertisement {
+    type: VersionType;
+    message: string;
+    protocol: number;
+    version: string;
+    playerCount: number;
+    maxPlayers: number;
+    serverGUID: number;
+    serverName: string;
+    gameMode: string;
+}
+
+export { type Advertisement, ConnectedPing, ConnectedPong, ConnectionRequest, ConnectionRequestAccepted, NewIncomingConnection, OpenConnectionFirstReply, OpenConnectionSecondReply, OpenConnectionSecondRequest, OpenFirstConnectionRequest, RakNetClient, Receiver, Sender, UnconnectedPing, type VersionType };