@mafiahub/types 0.1.0

package/core/color.d.ts

@@ -0,0 +1,34 @@
+declare namespace Core {
+    /**
+     * RGBA color. Components are stored as floats in [0, 1] range.
+     * Use `Color.fromRGB()` to construct from 0-255 values.
+     */
+    class Color {
+        constructor(r: number, g: number, b: number, a?: number);
+
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+
+        lerp(target: Color, t: number): this;
+        set(r: number, g: number, b: number, a?: number): this;
+        clone(): Color;
+        toHex(includeAlpha?: boolean): string;
+        toString(): string;
+        toJSON(): { r: number; g: number; b: number; a: number };
+
+        static fromHex(hex: string): Color;
+        /** Construct from 0-255 component values. */
+        static fromRGB(r: number, g: number, b: number, a?: number): Color;
+        static white(): Color;
+        static black(): Color;
+        static red(): Color;
+        static green(): Color;
+        static blue(): Color;
+        static yellow(): Color;
+        static cyan(): Color;
+        static magenta(): Color;
+        static transparent(): Color;
+    }
+}

package/core/events.d.ts

@@ -0,0 +1,42 @@
+declare namespace Core {
+    /**
+     * Global event bus with async support.
+     *
+     * Reserved events (framework-only, cannot be emitted from JS):
+     * `resourceStart`, `resourceStop`, `resourceError`,
+     * `playerConnect`, `playerDisconnect`, `playerSpawn`,
+     * `serverStart`, `serverStop`
+     */
+    const Events: {
+        /**
+         * Register a listener for an event.
+         * @returns An unsubscribe function.
+         */
+        on(eventName: string, handler: (...args: any[]) => void): () => void;
+
+        /** Register a one-time listener. */
+        once(eventName: string, handler: (...args: any[]) => void): void;
+
+        /** Remove a specific listener. */
+        off(eventName: string, handler: (...args: any[]) => void): void;
+
+        /**
+         * Emit an event globally. Reserved events cannot be emitted.
+         * Resolves when all handlers complete; rejects with
+         * `AggregateError` if any handler fails.
+         */
+        emit(eventName: string, ...args: any[]): Promise<void>;
+
+        /** Emit an event targeting a specific resource's listeners. */
+        emitTo(resourceName: string, eventName: string, ...args: any[]): Promise<void>;
+
+        /** Register a resource-local listener. */
+        onLocal(eventName: string, handler: (...args: any[]) => void): void;
+
+        /** Emit a resource-local event. */
+        emitLocal(eventName: string, ...args: any[]): Promise<void>;
+
+        /** Get the number of global listeners for an event. */
+        listenerCount(eventName: string): number;
+    };
+}

package/core/quaternion.d.ts

@@ -0,0 +1,27 @@
+declare namespace Core {
+    class Quaternion {
+        constructor(w: number, x: number, y: number, z: number);
+
+        w: number;
+        x: number;
+        y: number;
+        z: number;
+
+        multiply(other: Quaternion): this;
+        normalize(): this;
+        slerp(target: Quaternion, t: number): this;
+        conjugate(): Quaternion;
+        inverse(): Quaternion;
+        dot(other: Quaternion): number;
+        rotateVector(v: Vector3): Vector3;
+        toEuler(): Vector3;
+        set(w: number, x: number, y: number, z: number): this;
+        clone(): Quaternion;
+        toString(): string;
+        toJSON(): { w: number; x: number; y: number; z: number };
+
+        static identity(): Quaternion;
+        static fromEuler(pitch: number, yaw: number, roll: number): Quaternion;
+        static fromAxisAngle(axis: Vector3, angle: number): Quaternion;
+    }
+}

package/core/vector2.d.ts

@@ -0,0 +1,26 @@
+declare namespace Core {
+    class Vector2 {
+        constructor(x: number, y: number);
+
+        x: number;
+        y: number;
+        readonly length: number;
+        readonly lengthSquared: number;
+
+        add(other: Vector2): this;
+        sub(other: Vector2): this;
+        mul(scalar: number): this;
+        div(scalar: number): this;
+        normalize(): this;
+        dot(other: Vector2): number;
+        distance(other: Vector2): number;
+        lerp(target: Vector2, t: number): this;
+        set(x: number, y: number): this;
+        clone(): Vector2;
+        toString(): string;
+        toJSON(): { x: number; y: number };
+
+        static zero(): Vector2;
+        static one(): Vector2;
+    }
+}

package/core/vector3.d.ts

@@ -0,0 +1,31 @@
+declare namespace Core {
+    class Vector3 {
+        constructor(x: number, y: number, z: number);
+
+        x: number;
+        y: number;
+        z: number;
+        readonly length: number;
+        readonly lengthSquared: number;
+
+        add(other: Vector3): this;
+        sub(other: Vector3): this;
+        mul(scalar: number): this;
+        div(scalar: number): this;
+        normalize(): this;
+        dot(other: Vector3): number;
+        cross(other: Vector3): this;
+        distance(other: Vector3): number;
+        lerp(target: Vector3, t: number): this;
+        set(x: number, y: number, z: number): this;
+        clone(): Vector3;
+        toString(): string;
+        toJSON(): { x: number; y: number; z: number };
+
+        static zero(): Vector3;
+        static one(): Vector3;
+        static up(): Vector3;
+        static forward(): Vector3;
+        static right(): Vector3;
+    }
+}

package/core/vector4.d.ts

@@ -0,0 +1,28 @@
+declare namespace Core {
+    class Vector4 {
+        constructor(x: number, y: number, z: number, w: number);
+
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+        readonly length: number;
+        readonly lengthSquared: number;
+
+        add(other: Vector4): this;
+        sub(other: Vector4): this;
+        mul(scalar: number): this;
+        div(scalar: number): this;
+        normalize(): this;
+        dot(other: Vector4): number;
+        distance(other: Vector4): number;
+        lerp(target: Vector4, t: number): this;
+        set(x: number, y: number, z: number, w: number): this;
+        clone(): Vector4;
+        toString(): string;
+        toJSON(): { x: number; y: number; z: number; w: number };
+
+        static zero(): Vector4;
+        static one(): Vector4;
+    }
+}

package/framework/exports.d.ts

@@ -0,0 +1,13 @@
+declare namespace Framework {
+    const Exports: {
+        /** Register a named export from the current resource. */
+        register(name: string, value: any): boolean;
+
+        /**
+         * Get a specific export from another resource.
+         * Throws if the resource is not found, not running, or the export
+         * does not exist.
+         */
+        get(resourceName: string, exportName: string): any;
+    };
+}

package/framework/imports.d.ts

@@ -0,0 +1,9 @@
+declare namespace Framework {
+    const imports: {
+        /**
+         * Get the exports object from another resource.
+         * Throws if the resource is not found or not running.
+         */
+        get(resourceName: string): Record<string, any>;
+    };
+}

package/framework/messages.d.ts

@@ -0,0 +1,22 @@
+declare namespace Framework {
+    const messages: {
+        /**
+         * Register a handler for incoming messages of a given type.
+         * @param handler Receives `(payload, reply)`. Call `reply(value)`
+         *   to send a response back to the requester.
+         */
+        handle(
+            messageType: string,
+            handler: (payload: any, reply: (value: any) => void) => void,
+        ): void;
+
+        /**
+         * Send a request to another resource and await a reply.
+         * Rejects if the target resource has no handler or the handler throws.
+         */
+        request(resourceName: string, messageType: string, payload?: any): Promise<any>;
+
+        /** Fire-and-forget message to another resource. */
+        send(resourceName: string, messageType: string, payload?: any): void;
+    };
+}

package/index.d.ts

@@ -0,0 +1,9 @@
+/// <reference path="core/vector2.d.ts" />
+/// <reference path="core/vector3.d.ts" />
+/// <reference path="core/vector4.d.ts" />
+/// <reference path="core/quaternion.d.ts" />
+/// <reference path="core/color.d.ts" />
+/// <reference path="core/events.d.ts" />
+/// <reference path="framework/messages.d.ts" />
+/// <reference path="framework/imports.d.ts" />
+/// <reference path="framework/exports.d.ts" />

package/package.json

@@ -0,0 +1,20 @@
+{
+    "name": "@mafiahub/types",
+    "version": "0.1.0",
+    "description": "TypeScript type definitions for the MafiaHub Framework scripting API",
+    "types": "index.d.ts",
+    "files": [
+        "index.d.ts",
+        "core/*.d.ts",
+        "framework/*.d.ts"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/MafiaHub/Framework.git",
+        "directory": "types"
+    },
+    "license": "SEE LICENSE IN ../LICENSE",
+    "publishConfig": {
+        "access": "public"
+    }
+}