rock-mod 0.7.3 → 0.8.1

package/dist/server/factories/mock/MockManagersFactory.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockManagersFactory = void 0;
+const MockNetManager_1 = require("../../net/mock/MockNetManager");
+const MockPlayersManager_1 = require("../../entities/mock/player/MockPlayersManager");
+const MockBlipsManager_1 = require("../../entities/mock/blip/MockBlipsManager");
+const MockColshapesManager_1 = require("../../entities/mock/colshape/MockColshapesManager");
+const MockMarkersManager_1 = require("../../entities/mock/marker/MockMarkersManager");
+const MockObjectsManager_1 = require("../../entities/mock/object/MockObjectsManager");
+const MockPedsManager_1 = require("../../entities/mock/ped/MockPedsManager");
+const MockVehiclesManager_1 = require("../../entities/mock/vehicle/MockVehiclesManager");
+const MockUtilsManager_1 = require("../../utils/mock/MockUtilsManager");
+class MockManagersFactory {
+    createNetManager() {
+        return new MockNetManager_1.MockNetManager();
+    }
+    createBlipsManager() {
+        return new MockBlipsManager_1.MockBlipsManager();
+    }
+    createColshapesManager() {
+        return new MockColshapesManager_1.MockColshapesManager();
+    }
+    createMarkersManager() {
+        return new MockMarkersManager_1.MockMarkersManager();
+    }
+    createObjectsManager() {
+        return new MockObjectsManager_1.MockObjectsManager();
+    }
+    createPedsManager() {
+        return new MockPedsManager_1.MockPedsManager();
+    }
+    createPlayersManager() {
+        return new MockPlayersManager_1.MockPlayersManager();
+    }
+    createUtilsManager() {
+        return new MockUtilsManager_1.MockUtilsManager();
+    }
+    createVehiclesManager() {
+        return new MockVehiclesManager_1.MockVehiclesManager();
+    }
+}
+exports.MockManagersFactory = MockManagersFactory;

package/dist/server/index.d.ts

@@ -1,3 +1,6 @@
 export * from "./RockMod";
-export * from "./entities";
 export * from "./common/utils";
+export { BaseObjectType, IBaseObject as IRockModBaseObject, IBlip as IRockModBlip, IColshape as IRockModColshape, IEntity as IRockModEntity, IMarker as IRockModMarker, IObject as IRockModObject, IPed as IRockModPed, IPlayer as IRockModPlayer, IVehicle as IRockModVehicle, IWorldObject as IRockModWorldObject, } from "./entities";
+export { INetServerEvents, INetClientEvents } from "./net/common/events/IEventsManager";
+export { INetServerRPC, INetClientRPC } from "./net/common/rpc/IRPCManager";
+export * from "./testing";

package/dist/server/index.js

@@ -14,6 +14,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseObjectType = void 0;
 __exportStar(require("./RockMod"), exports);
-__exportStar(require("./entities"), exports);
 __exportStar(require("./common/utils"), exports);
+var entities_1 = require("./entities");
+Object.defineProperty(exports, "BaseObjectType", { enumerable: true, get: function () { return entities_1.BaseObjectType; } });
+__exportStar(require("./testing"), exports);

package/dist/server/net/mock/MockNetManager.d.ts

@@ -0,0 +1,10 @@
+import { INetManager } from "../common/INetManager";
+import { MockEventsManager } from "./events/MockEventsManager";
+import { MockRPCManager } from "./rpc/MockRPCManager";
+export declare class MockNetManager implements INetManager {
+    private readonly _eventsManager;
+    private readonly _rpcManager;
+    get events(): MockEventsManager;
+    get rpc(): MockRPCManager;
+    constructor();
+}

package/dist/server/net/mock/MockNetManager.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockNetManager = void 0;
+const MockEventsManager_1 = require("./events/MockEventsManager");
+const MockRPCManager_1 = require("./rpc/MockRPCManager");
+class MockNetManager {
+    _eventsManager;
+    _rpcManager;
+    get events() {
+        return this._eventsManager;
+    }
+    get rpc() {
+        return this._rpcManager;
+    }
+    constructor() {
+        this._eventsManager = new MockEventsManager_1.MockEventsManager();
+        this._rpcManager = new MockRPCManager_1.MockRPCManager();
+    }
+}
+exports.MockNetManager = MockNetManager;

package/dist/server/net/mock/events/MockEventsManager.d.ts

@@ -0,0 +1,18 @@
+import { IEventsManager, INetClientEvents, INetServerEvents } from "../../common/events/IEventsManager";
+import { MockPlayer } from "../../../entities/mock/player/MockPlayer";
+import { MockBaseObject } from "../../../entities/mock/baseObject/MockBaseObject";
+export interface IMockServerEvents extends INetServerEvents {
+    "rm::playerConnected"(player: MockPlayer): void;
+    "rm::playerDisconnected"(player: MockPlayer): void;
+    "rm::entityCreated"(entity: MockBaseObject): void;
+    "rm::entityDestroyed"(entity: MockBaseObject): void;
+}
+export interface IMockClientEvents extends INetClientEvents {
+}
+export declare class MockEventsManager implements IEventsManager {
+    private readonly _eventEmitter;
+    on<K extends keyof IMockServerEvents>(events: Record<K, (...args: Parameters<IMockServerEvents[K]>) => void>): void;
+    off<K extends keyof IMockServerEvents>(eventName: K, listener: (...args: Parameters<IMockServerEvents[K]>) => void): void;
+    emit<K extends keyof IMockServerEvents>(eventName: K, ...args: Parameters<IMockServerEvents[K]>): void;
+    emitClient(): void;
+}

package/dist/server/net/mock/events/MockEventsManager.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockEventsManager = void 0;
+const events_1 = require("events");
+class MockEventsManager {
+    _eventEmitter = new events_1.EventEmitter();
+    on(events) {
+        for (const [eventName, handler] of Object.entries(events)) {
+            this._eventEmitter.on(eventName, handler);
+        }
+    }
+    off(eventName, listener) {
+        this._eventEmitter.off(eventName, listener);
+    }
+    emit(eventName, ...args) {
+        this._eventEmitter.emit(eventName, ...args);
+    }
+    emitClient() {
+        throw new Error("Method not implemented");
+    }
+}
+exports.MockEventsManager = MockEventsManager;

package/dist/server/net/mock/rpc/MockRPCManager.d.ts

@@ -0,0 +1,13 @@
+import { INetClientRPC, INetServerRPC, IRPCManager } from "../../common/rpc/IRPCManager";
+import { IPlayer } from "../../../entities/common/player/IPlayer";
+import { MockPlayer } from "../../../entities/mock/player/MockPlayer";
+export interface IMockServerRPC extends INetServerRPC {
+}
+export interface IMockClientRPC extends INetClientRPC {
+}
+export declare class MockRPCManager implements IRPCManager {
+    private readonly _handlers;
+    register<K extends keyof IMockServerRPC>(rpcName: K, handler: (player: MockPlayer, ...args: Parameters<IMockServerRPC[K]>) => ReturnType<IMockServerRPC[K]>): void;
+    unregister<K extends keyof IMockServerRPC>(rpcName: K): void;
+    emitClient<K extends keyof IMockClientRPC>(player: IPlayer, rpcName: K, ...args: Parameters<IMockClientRPC[K]>): Promise<ReturnType<IMockClientRPC[K]>>;
+}

package/dist/server/net/mock/rpc/MockRPCManager.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockRPCManager = void 0;
+class MockRPCManager {
+    _handlers = new Map();
+    register(rpcName, handler) {
+        this._handlers.set(rpcName, handler);
+    }
+    unregister(rpcName) {
+        this._handlers.delete(rpcName);
+    }
+    emitClient(player, rpcName, ...args) {
+        const handler = this._handlers.get(rpcName);
+        if (handler) {
+            try {
+                const result = handler(player, ...args);
+                return Promise.resolve(result);
+            }
+            catch (error) {
+                return Promise.reject(error);
+            }
+        }
+        return Promise.resolve(null);
+    }
+}
+exports.MockRPCManager = MockRPCManager;

package/dist/server/testing.d.ts

@@ -0,0 +1,8 @@
+import { MockPlayer } from "entities/mock/player/MockPlayer";
+import { IMockPlayerConnectOptions } from "./entities/mock/player/MockPlayersManager";
+export declare class RockModTesting {
+    static simulatePlayerConnect(options?: IMockPlayerConnectOptions): MockPlayer;
+    static simulatePlayerDisconnect(player: MockPlayer): void;
+    static createMockPlayerNow(options?: IMockPlayerConnectOptions): MockPlayer;
+}
+export { IMockPlayerConnectOptions, type MockPlayer };

package/dist/server/testing.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RockModTesting = void 0;
+const RockMod_1 = require("./RockMod");
+class RockModTesting {
+    static simulatePlayerConnect(options) {
+        const manager = RockMod_1.RockMod.instance.players;
+        return manager.simulateConnect(options);
+    }
+    static simulatePlayerDisconnect(player) {
+        const manager = RockMod_1.RockMod.instance.players;
+        return manager.simulateDisconnect(player);
+    }
+    static createMockPlayerNow(options) {
+        const manager = RockMod_1.RockMod.instance.players;
+        return manager.createPlayer(options);
+    }
+}
+exports.RockModTesting = RockModTesting;

package/dist/server/utils/mock/MockUtilsManager.d.ts

@@ -0,0 +1,4 @@
+import { IUtilsManager } from "../common";
+export declare class MockUtilsManager implements IUtilsManager {
+    hash(value: string): number;
+}

package/dist/server/utils/mock/MockUtilsManager.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockUtilsManager = void 0;
+class MockUtilsManager {
+    hash(value) {
+        // Simple hash function for mock mode
+        let hash = 0;
+        for (let i = 0; i < value.length; i++) {
+            const char = value.charCodeAt(i);
+            hash = (hash << 5) - hash + char;
+            hash = hash & hash; // Convert to 32bit integer
+        }
+        return hash;
+    }
+}
+exports.MockUtilsManager = MockUtilsManager;

package/package.json

@@ -1,9 +1,26 @@
 {
   "name": "rock-mod",
-  "version": "0.7.3",
+  "version": "0.8.1",
   "description": "Rock-Mod is a powerful framework designed for creating and managing mods for Grand Theft Auto (GTA) games.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./testing": {
+      "types": "./dist/testing.d.ts",
+      "default": "./dist/testing.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "testing": [
+        "./dist/testing.d.ts"
+      ]
+    }
+  },
   "scripts": {
     "start": "npx tsx src/server/index.ts",
     "build": "npm run build:server && npm run build:client",
@@ -16,7 +33,7 @@
     "lint:check": "npm run lint:server:check && npm run lint:client:check",
     "lint:fix": "npm run lint:server:fix && npm run lint:client:fix",
     "format:check": "prettier --check .",
-    "format:fix": "prettier --write .",
+    "format:fix": "prettier --write . --log-level=silent",
     "type:server:check": "tsc --noEmit --project src/server/tsconfig.json",
     "type:client:check": "tsc --noEmit --project src/client/tsconfig.json",
     "type:check": "npm run type:server:check && npm run type:client:check",
@@ -57,6 +74,7 @@
     "husky": "^9.1.6",
     "lint-staged": "^15.2.10",
     "prettier": "^3.3.3",
-    "typescript": "^5.6.2"
+    "typescript": "^5.6.2",
+    "@types/node": "^20.10.4"
   }
 }