Update definitions

Author: Plextora

definitions/feature/hudmodule.d.ts

@@ -2,7 +2,7 @@ declare class HudModule extends Module {
     constructor(name: string, displayName: string, description: string, key: KeyCode, resizable: boolean);
 
     getRect(): Rect;
-    setRect(newRect: Rect): void;
+    setRect(newRect: IRect): void;
     setBounds(width: number, height: number): void;
     getSize(): number;
     setSize(): number;

definitions/feature/screen.d.ts

@@ -52,7 +52,7 @@ declare class Screen {
      * @param rect The rectangle to check bounds
      * @param point The point to check (by default, mouse position.)
      */
-    isHover(rect: Rect, point?: Vector2): boolean;
+    isHover(rect: IRect, point?: IVector2): boolean;
 
     /**
      * If the screen is currently on or off

definitions/gfx/graphics.d.ts

@@ -1,11 +1,27 @@
+declare interface IRect {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}
+
+declare interface IVector2 {
+    x: number;
+    y: number;
+}
+
+declare interface IVector3 extends IVector2 {
+    z: number;
+}
+
 /**
  * A class representing a rectangle on the screen.
  * @member left The x coordinate of the top-left point.
  * @member top The y coordinate of the top-left point.
  * @member right The x coordinate of the bottom-right point.
  * @member bottom The y coordinate of the bottom-right point.
  */
-declare class Rect {
+declare class Rect implements IRect {
     /**
      * 
      * @param left The x coordinate of the top-left point.
@@ -24,12 +40,13 @@ declare class Rect {
     getHeight(): number;
 }
 
-declare class Vector2 {
-    add: (vec: Vector2) => Vector2;
-    sub: (vec: Vector2) => Vector2;
-    mul: (vec: Vector2) => Vector2;
-    div: (vec: Vector2) => Vector2;
-    distanceTo: (pos: Vector2) => number;
+
+declare class Vector2 implements IVector2 {
+    add: (vec: IVector2) => Vector2;
+    sub: (vec: IVector2) => Vector2;
+    mul: (vec: IVector2) => Vector2;
+    div: (vec: IVector2) => Vector2;
+    distanceTo: (pos: IVector2) => number;
     /**
      * A point on the screen.
      * @param x The x coordinate.
@@ -42,15 +59,20 @@ declare class Vector2 {
     y: number;
 }
 
-declare class Vector3 {
-    add: (vec: Vector3) => Vector3;
-    sub: (vec: Vector3) => Vector3;
-    mul: (vec: Vector3) => Vector3;
-    div: (vec: Vector3) => Vector3;
-    distanceTo: (pos: Vector3) => number;
+declare class Vector3 implements IVector3 {
+    add: (vec: IVector3) => Vector3;
+    sub: (vec: IVector3) => Vector3;
+    mul: (vec: IVector3) => Vector3;
+    div: (vec: IVector3) => Vector3;
+    distanceTo: (pos: IVector3) => number;
 
     constructor(x: number, y: number, z: number);
+
+    /**
+     * Create a `Vector3` object with all fields initialized to `0`
+     */
     constructor();
+
     x: number;
     y: number;
     z: number;
@@ -82,7 +104,7 @@ declare class Color {
      * @param b Blue (0 to 255)
      * @param a Opacity (0 to 255)
      */
-    static RGB(r: number, g: number, b: number, a: number | undefined): Color;
+    static RGB(r: number, g: number, b: number, a?: number): Color;
 
     static WHITE: Color;
     static BLACK: Color;
@@ -105,22 +127,20 @@ declare const enum VerticalAlignment {
 
 type BackendType 
     = 
-    /**
-     *  */
-    "dx";
+    "dx" | "minecraft";
 
 declare interface Graphics {
     /**
      * 
      * @param renderer `"dx"`: uses Direct2D/DirectWrite, `"minecraft":` use the Minecraft renderer
      */
-    use(renderer: "dx" | "minecraft"): void;
-    drawRect(rect: Rect, color: Color, thickness: number, radius?: number): void;
-    fillRect(rect: Rect, color: Color, radius?: number): void;
+    use(renderer: BackendType): void;
+    drawRect(rect: IRect, color: Color, thickness: number, radius?: number): void;
+    fillRect(rect: IRect, color: Color, radius?: number): void;
 
     getTextSize(text: string, textSize: number): Vector2;
 
-    setClippingRect(rect: Rect): void;
+    setClippingRect(rect: IRect): void;
     restoreClippingRect(): void;
 
     /**
@@ -130,7 +150,7 @@ declare interface Graphics {
      * @param size The size of the text in pixels
      * @param color The color of the text
      */
-    drawText(pos: Vector2, text: string, size: number, color: Color): void;
+    drawText(pos: IVector2, text: string, size: number, color: Color): void;
 
     /**
      * A full verison of drawText, where you can specify the bounds of the text and the alignment
@@ -141,7 +161,7 @@ declare interface Graphics {
      * @param alignment The horizontal alignment
      * @param verticalAlignment The vertical alignment
      */
-    drawTextFull(area: Rect, text: string, size: number, color: Color, alignment: TextAlignment, verticalAlignment: VerticalAlignment): void;
+    drawTextFull(area: IRect, text: string, size: number, color: Color, alignment: TextAlignment, verticalAlignment: VerticalAlignment): void;
 
     /**
      * Draws a texture.
@@ -151,7 +171,7 @@ declare interface Graphics {
      * @param sizeY The size of the texture in pixels
      * @param color The overlay color of the texture (defaults to white)
      */
-    drawTexture(texture: Texture, pos: Vector2, sizeX: number, sizeY: number, color?: Color): void;
+    drawTexture(texture: Texture, pos: IVector2, sizeX: number, sizeY: number, color?: Color): void;
 
     /**
      * Draw an item instance.
@@ -160,7 +180,7 @@ declare interface Graphics {
      * @param sizeModifier The relative size modifier (defualt: 1.0, aka 16 pixels)
      * @param opacity The opacity of the item
      */
-    drawItem(item: ItemStack, pos: Vector2, sizeModifier: number, opacity: number): void;
+    drawItem(item: ItemStack, pos: IVector2, sizeModifier: number, opacity: number): void;
 }
 
 declare const graphics: Graphics;

definitions/gfx/graphics3.d.ts

@@ -17,15 +17,15 @@ declare interface Graphics3D {
      * @param p1 
      * @param p2 
      */
-    drawLine(p1: Vector3, p2: Vector3): void;
+    drawLine(p1: IVector3, p2: IVector3): void;
 
     /**
      * Draws a triangle into the world (adds a triangle into the vertex buffer)
      * @param p1 
      * @param p2 
      * @param p3
      */
-    drawTriangle(p1: Vector3, p2: Vector3, p3: Vector3): void;
+    drawTriangle(p1: IVector3, p2: IVector3, p3: IVector3): void;
 
     /**
      * Draws a quad into the world (adds a quad into the vertex buffer)
@@ -34,7 +34,7 @@ declare interface Graphics3D {
      * @param p3
      * @param p4
      */
-    drawQuad(p1: Vector3, p2: Vector3, p3: Vector3, p4: Vector3): void;
+    drawQuad(p1: IVector3, p2: IVector3, p3: IVector3, p4: IVector3): void;
 
     /**
      * Call this every time you're done rendering. (batched renders the current vertex buffer into the world) 

definitions/util/buffer.d.ts

@@ -1,13 +1,33 @@
 declare interface Uint8Array {
+    /**
+     * Read a 16-bit, little-endian integer at the specified index.
+     */
     readInt16(idx: number): number;
+    /**
+     * Read a 32-bit, little-endian integer at the specified index.
+     */
     readInt32(idx: number): number;
+    /**
+     * Read a 64-bit, little-endian integer at the specified index, but truncated as a JavaScript `number` value. The maximum safely usable value that can be returned by this function is `Number.MAX_SAFE_INTEGER`.
+     */
     readInt64AsFloat(idx: number): number;
 
+    /**
+     * Read a JavaScript-standard 32 bit floating point number at the specified index. 
+     */
     readFloat32(idx: number): number;
+    /**
+     * Read a JavaScript-standard 64 bit floating point number at the specified index. 
+     */
     readFloat64(idx: number): number;
 
-    /// Reads a null-terminated string
+    /**
+     * Reads a null-terminated byte-per-character string at the specified index.
+     */
     readString(idx: number): string;
 }
 
+/**
+ * This declaration reperesents the interface used by the Latite API to represent byte arrays.
+ */
 declare type Buffer = Uint8Array;

definitions/websocket/WebSocket.d.ts

@@ -0,0 +1,24 @@
+declare const enum WebSocketEncoding {
+    Binary = 0,
+    Utf8 = 1
+}
+
+interface WebSocketEvents {
+    /**
+    * Called on a message being received.
+    * @param data The data being received. Could be a string or buffer depending on the `WebSocketEncoding`.
+    */
+    "receive": (data: Buffer | string) => void,
+    /**
+    * Called on the WebSocket server or client closing the connection.
+    */
+    "close": () => void,
+}
+
+declare class WebSocket {
+    constructor(url: string, encoding: WebSocketEncoding)
+
+    send: (data: string | Buffer) => void
+    close: (code?: number, reason?: string) => void
+    on: <K extends keyof WebSocketEvents>(eventName: K, handler: WebSocketEvents[K]) => void;
+}

definitions/world/entity.d.ts

@@ -137,7 +137,7 @@ declare class Entity {
      * This function is restricted - it only works if you have operator.
      * @param vector The new velocity
      */
-    setVelocity(vector: Vector3): void;
+    setVelocity(vector: IVector3): void;
 }
 
 declare class Player extends Entity {