rock-mod 0.0.0

package/dist/server/entities/common/baseObject/IBaseObjectsManager.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/server/entities/common/entity/IEntitiesManager.d.ts

@@ -0,0 +1,6 @@
+import { IWorldObjectsManager, IWorldObjectsManagerOptions } from "../worldObject/IWorldObjectsManager";
+import { IEntity } from "./IEntity";
+export interface IEntitiesManagerOptions extends IWorldObjectsManagerOptions {
+}
+export interface IEntitiesManager<T extends IEntity> extends IWorldObjectsManager<T> {
+}

package/dist/server/entities/common/entity/IEntitiesManager.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/server/entities/common/entity/IEntity.d.ts

@@ -0,0 +1,8 @@
+import { IWorldObject, IWorldObjectOptions } from "../worldObject/IWorldObject";
+export interface IEntityOptions extends IWorldObjectOptions {
+    model: string;
+}
+export interface IEntity extends IWorldObject {
+    get model(): string;
+    setModel(value: string): void;
+}

package/dist/server/entities/common/entity/IEntity.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/server/entities/common/player/IPlayer.d.ts

@@ -0,0 +1,12 @@
+import { IEntity, IEntityOptions } from "../entity/IEntity";
+export interface IPlayerOptions extends IEntityOptions {
+    name: string;
+    socialClub: string;
+}
+export interface IPlayer extends IEntity {
+    get name(): string;
+    get socialClub(): string;
+    get health(): number;
+    setName(value: string): void;
+    setHealth(value: number): void;
+}

package/dist/server/entities/common/player/IPlayer.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/server/entities/common/player/IPlayersManager.d.ts

@@ -0,0 +1,8 @@
+import { IEntitiesManager } from "../entity/IEntitiesManager";
+import { IPlayer } from "./IPlayer";
+export interface IPlayersManager extends IEntitiesManager<IPlayer> {
+    getByName(name: string): IPlayer;
+    findByName(name: string): IPlayer | null;
+    getBySocialClub(socialClub: string): IPlayer;
+    findBySocialClub(socialClub: string): IPlayer | null;
+}

package/dist/server/entities/common/player/IPlayersManager.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/server/entities/common/vehicle/IVehicle.d.ts

@@ -0,0 +1,7 @@
+import { IEntity, IEntityOptions } from "../entity/IEntity";
+export interface IVehicleOptions extends IEntityOptions {
+}
+export interface IVehicle extends IEntity {
+    get bodyHealth(): number;
+    setBodyHealth(value: number): void;
+}

package/dist/server/entities/common/vehicle/IVehicle.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/server/entities/common/vehicle/IVehiclesManager.d.ts

@@ -0,0 +1,4 @@
+import { IEntitiesManager } from "../entity/IEntitiesManager";
+import { IVehicle } from "./IVehicle";
+export interface IVehiclesManager extends IEntitiesManager<IVehicle> {
+}

package/dist/server/entities/common/vehicle/IVehiclesManager.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/server/entities/common/worldObject/IWorldObject.d.ts

@@ -0,0 +1,10 @@
+import { IBaseObject, IBaseObjectOptions } from "../baseObject/IBaseObject";
+import { Vector3D } from "../../../common/utils/math/Vectors";
+export interface IWorldObjectOptions extends IBaseObjectOptions {
+    position: Vector3D;
+    dimension: number;
+}
+export interface IWorldObject extends IBaseObject {
+    position: Vector3D;
+    dimension: number;
+}

package/dist/server/entities/common/worldObject/IWorldObject.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/server/entities/common/worldObject/IWorldObjectsIterator.d.ts

@@ -0,0 +1,8 @@
+import { IBaseObjectsIterator } from "../baseObject/IBaseObjectsIterator";
+import { IWorldObject } from "./IWorldObject";
+import { Vector2D, Vector3D } from "../../../common/utils/math/Vectors";
+export interface IWorldObjectsIterator<T extends IWorldObject> extends IBaseObjectsIterator<T> {
+    dimension(value: number): IterableIterator<T>;
+    range2D(center: Vector2D, range: number): IterableIterator<T>;
+    range3D(center: Vector3D, range: number): IterableIterator<T>;
+}

package/dist/server/entities/common/worldObject/IWorldObjectsIterator.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/server/entities/common/worldObject/IWorldObjectsManager.d.ts

@@ -0,0 +1,8 @@
+import { IBaseObjectsManager, IBaseObjectsManagerOptions } from "../baseObject/IBaseObjectsManager";
+import { IWorldObject } from "./IWorldObject";
+import { IWorldObjectsIterator } from "./IWorldObjectsIterator";
+export interface IWorldObjectsManagerOptions extends IBaseObjectsManagerOptions {
+}
+export interface IWorldObjectsManager<T extends IWorldObject> extends IBaseObjectsManager<T> {
+    get iterator(): IWorldObjectsIterator<T>;
+}

package/dist/server/entities/common/worldObject/IWorldObjectsManager.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/server/entities/ragemp/RageManagersFactory.d.ts

@@ -0,0 +1,7 @@
+import { IManagersFactory } from "../common/IManagersFactory";
+import { RagePlayersManager } from "./player/RagePlayersManager";
+import { RageVehiclesManager } from "./vehicle/RageVehiclesManager";
+export declare class RageManagersFactory implements IManagersFactory {
+    createPlayersManager(): RagePlayersManager;
+    createVehiclesManager(): RageVehiclesManager;
+}

package/dist/server/entities/ragemp/RageManagersFactory.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageManagersFactory = void 0;
+const RagePlayersManager_1 = require("./player/RagePlayersManager");
+const RageVehiclesManager_1 = require("./vehicle/RageVehiclesManager");
+class RageManagersFactory {
+    createPlayersManager() {
+        return new RagePlayersManager_1.RagePlayersManager();
+    }
+    createVehiclesManager() {
+        return new RageVehiclesManager_1.RageVehiclesManager();
+    }
+}
+exports.RageManagersFactory = RageManagersFactory;

package/dist/server/entities/ragemp/baseObject/RageBaseObject.d.ts

@@ -0,0 +1,9 @@
+import { BaseObjectType, IBaseObject, IBaseObjectOptions } from "../../common/baseObject/IBaseObject";
+export declare abstract class RageBaseObject implements IBaseObject {
+    private readonly _id;
+    private readonly _type;
+    get id(): number;
+    get type(): BaseObjectType;
+    protected constructor(options: IBaseObjectOptions);
+    destroy(): void;
+}

package/dist/server/entities/ragemp/baseObject/RageBaseObject.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageBaseObject = void 0;
+class RageBaseObject {
+    _id;
+    _type;
+    get id() {
+        return this._id;
+    }
+    get type() {
+        return this._type;
+    }
+    constructor(options) {
+        this._id = options.id;
+        this._type = options.type;
+    }
+    destroy() {
+        console.log("destroy");
+    }
+}
+exports.RageBaseObject = RageBaseObject;

package/dist/server/entities/ragemp/baseObject/RageBaseObjectsIterator.d.ts

@@ -0,0 +1,7 @@
+import { IBaseObjectsIterator } from "../../common/baseObject/IBaseObjectsIterator";
+import { RageBaseObject } from "./RageBaseObject";
+export declare class RageBaseObjectsIterator<T extends RageBaseObject> implements IBaseObjectsIterator<T> {
+    private readonly _baseObjects;
+    constructor(baseObjects: ReadonlyMap<number, T>);
+    all(): IterableIterator<T>;
+}

package/dist/server/entities/ragemp/baseObject/RageBaseObjectsIterator.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageBaseObjectsIterator = void 0;
+class RageBaseObjectsIterator {
+    _baseObjects;
+    constructor(baseObjects) {
+        this._baseObjects = baseObjects;
+    }
+    all() {
+        return this._baseObjects.values();
+    }
+}
+exports.RageBaseObjectsIterator = RageBaseObjectsIterator;

package/dist/server/entities/ragemp/baseObject/RageBaseObjectsManager.d.ts

@@ -0,0 +1,13 @@
+import { IBaseObjectsManager, IBaseObjectsManagerOptions } from "../../common/baseObject/IBaseObjectsManager";
+import { RageBaseObject } from "./RageBaseObject";
+import { RageBaseObjectsIterator } from "./RageBaseObjectsIterator";
+export declare abstract class RageBaseObjectsManager<T extends RageBaseObject> implements IBaseObjectsManager<RageBaseObject> {
+    private readonly _baseObjects;
+    private readonly _baseObjectsType;
+    protected readonly _iterator: RageBaseObjectsIterator<T>;
+    protected get baseObjects(): ReadonlyMap<number, T>;
+    get iterator(): RageBaseObjectsIterator<T>;
+    protected constructor(options: IBaseObjectsManagerOptions);
+    getByID(id: number): T;
+    findByID(id: number): T | null;
+}

package/dist/server/entities/ragemp/baseObject/RageBaseObjectsManager.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageBaseObjectsManager = void 0;
+const RageBaseObjectsIterator_1 = require("./RageBaseObjectsIterator");
+class RageBaseObjectsManager {
+    _baseObjects;
+    _baseObjectsType;
+    _iterator;
+    get baseObjects() {
+        return this._baseObjects;
+    }
+    get iterator() {
+        return this._iterator;
+    }
+    constructor(options) {
+        this._baseObjects = new Map();
+        this._baseObjectsType = options.baseObjectsType;
+        this._iterator = new RageBaseObjectsIterator_1.RageBaseObjectsIterator(this._baseObjects);
+    }
+    getByID(id) {
+        const baseObject = this.findByID(id);
+        if (!baseObject) {
+            throw new Error(`BaseObject [${this._baseObjectsType}] with id ${id} not found`);
+        }
+        return baseObject;
+    }
+    findByID(id) {
+        const baseObject = this._baseObjects.get(id);
+        return baseObject ?? null;
+    }
+}
+exports.RageBaseObjectsManager = RageBaseObjectsManager;

package/dist/server/entities/ragemp/entity/RageEntitiesManager.d.ts

@@ -0,0 +1,6 @@
+import { IEntitiesManager, IEntitiesManagerOptions } from "../../common/entity/IEntitiesManager";
+import { RageEntity } from "./RageEntity";
+import { RageWorldObjectsManager } from "../worldObject/RageWorldObjectsManager";
+export declare abstract class RageEntitiesManager<T extends RageEntity> extends RageWorldObjectsManager<T> implements IEntitiesManager<T> {
+    protected constructor(options: IEntitiesManagerOptions);
+}

package/dist/server/entities/ragemp/entity/RageEntitiesManager.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageEntitiesManager = void 0;
+const RageWorldObjectsManager_1 = require("../worldObject/RageWorldObjectsManager");
+class RageEntitiesManager extends RageWorldObjectsManager_1.RageWorldObjectsManager {
+    constructor(options) {
+        super(options);
+    }
+}
+exports.RageEntitiesManager = RageEntitiesManager;

package/dist/server/entities/ragemp/entity/RageEntity.d.ts

@@ -0,0 +1,8 @@
+import { IEntity, IEntityOptions } from "../../common/entity/IEntity";
+import { RageWorldObject } from "../worldObject/RageWorldObject";
+export declare abstract class RageEntity extends RageWorldObject implements IEntity {
+    private _model;
+    get model(): string;
+    protected constructor(options: IEntityOptions);
+    setModel(value: string): void;
+}

package/dist/server/entities/ragemp/entity/RageEntity.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageEntity = void 0;
+const RageWorldObject_1 = require("../worldObject/RageWorldObject");
+class RageEntity extends RageWorldObject_1.RageWorldObject {
+    _model;
+    get model() {
+        return this._model;
+    }
+    constructor(options) {
+        super(options);
+        this._model = options.model;
+    }
+    setModel(value) {
+        this._model = value;
+    }
+}
+exports.RageEntity = RageEntity;

package/dist/server/entities/ragemp/player/RagePlayer.d.ts

@@ -0,0 +1,13 @@
+import { RageEntity } from "../entity/RageEntity";
+import { IPlayer, IPlayerOptions } from "../../common/player/IPlayer";
+export declare class RagePlayer extends RageEntity implements IPlayer {
+    private _name;
+    private readonly _socialClub;
+    private _health;
+    get name(): string;
+    get socialClub(): string;
+    get health(): number;
+    constructor(options: IPlayerOptions);
+    setName(value: string): void;
+    setHealth(value: number): void;
+}

package/dist/server/entities/ragemp/player/RagePlayer.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RagePlayer = void 0;
+const RageEntity_1 = require("../entity/RageEntity");
+class RagePlayer extends RageEntity_1.RageEntity {
+    _name;
+    _socialClub;
+    _health;
+    get name() {
+        return this._name;
+    }
+    get socialClub() {
+        return this._socialClub;
+    }
+    get health() {
+        return this._health;
+    }
+    constructor(options) {
+        super(options);
+        this._name = options.name;
+        this._socialClub = options.socialClub;
+        this._health = 100;
+    }
+    setName(value) {
+        this._name = value;
+    }
+    setHealth(value) {
+        this._health = value;
+    }
+}
+exports.RagePlayer = RagePlayer;

package/dist/server/entities/ragemp/player/RagePlayersManager.d.ts

@@ -0,0 +1,10 @@
+import { RageEntitiesManager } from "../entity/RageEntitiesManager";
+import { RagePlayer } from "./RagePlayer";
+import { IPlayersManager } from "../../common/player/IPlayersManager";
+export declare class RagePlayersManager extends RageEntitiesManager<RagePlayer> implements IPlayersManager {
+    constructor();
+    getByName(name: string): RagePlayer;
+    findByName(name: string): RagePlayer | null;
+    getBySocialClub(socialClub: string): RagePlayer;
+    findBySocialClub(socialClub: string): RagePlayer | null;
+}

package/dist/server/entities/ragemp/player/RagePlayersManager.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RagePlayersManager = void 0;
+const RageEntitiesManager_1 = require("../entity/RageEntitiesManager");
+class RagePlayersManager extends RageEntitiesManager_1.RageEntitiesManager {
+    constructor() {
+        super({
+            baseObjectsType: "player",
+        });
+    }
+    getByName(name) {
+        const player = this.findByName(name);
+        if (!player) {
+            throw new Error(`Player with name ${name} not found`);
+        }
+        return player;
+    }
+    findByName(name) {
+        for (const player of this.iterator.all()) {
+            if (player.name === name) {
+                return player;
+            }
+        }
+        return null;
+    }
+    getBySocialClub(socialClub) {
+        const player = this.findBySocialClub(socialClub);
+        if (!player) {
+            throw new Error(`Player with socialClub ${socialClub} not found`);
+        }
+        return player;
+    }
+    findBySocialClub(socialClub) {
+        for (const player of this.iterator.all()) {
+            if (player.socialClub === socialClub) {
+                return player;
+            }
+        }
+        return null;
+    }
+}
+exports.RagePlayersManager = RagePlayersManager;

package/dist/server/entities/ragemp/vehicle/RageVehicle.d.ts

@@ -0,0 +1,8 @@
+import { RageEntity } from "../entity/RageEntity";
+import { IVehicle, IVehicleOptions } from "../../common/vehicle/IVehicle";
+export declare class RageVehicle extends RageEntity implements IVehicle {
+    private _bodyHealth;
+    get bodyHealth(): number;
+    constructor(options: IVehicleOptions);
+    setBodyHealth(value: number): void;
+}

package/dist/server/entities/ragemp/vehicle/RageVehicle.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageVehicle = void 0;
+const RageEntity_1 = require("../entity/RageEntity");
+class RageVehicle extends RageEntity_1.RageEntity {
+    _bodyHealth;
+    get bodyHealth() {
+        return this._bodyHealth;
+    }
+    constructor(options) {
+        super(options);
+        this._bodyHealth = 100;
+    }
+    setBodyHealth(value) {
+        this._bodyHealth = value;
+    }
+}
+exports.RageVehicle = RageVehicle;

package/dist/server/entities/ragemp/vehicle/RageVehiclesManager.d.ts

@@ -0,0 +1,6 @@
+import { RageEntitiesManager } from "../entity/RageEntitiesManager";
+import { RageVehicle } from "./RageVehicle";
+import { IVehiclesManager } from "../../common/vehicle/IVehiclesManager";
+export declare class RageVehiclesManager extends RageEntitiesManager<RageVehicle> implements IVehiclesManager {
+    constructor();
+}

package/dist/server/entities/ragemp/vehicle/RageVehiclesManager.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageVehiclesManager = void 0;
+const RageEntitiesManager_1 = require("../entity/RageEntitiesManager");
+class RageVehiclesManager extends RageEntitiesManager_1.RageEntitiesManager {
+    constructor() {
+        super({
+            baseObjectsType: "vehicle",
+        });
+    }
+}
+exports.RageVehiclesManager = RageVehiclesManager;

package/dist/server/entities/ragemp/worldObject/RageWorldObject.d.ts

@@ -0,0 +1,10 @@
+import { IWorldObject, IWorldObjectOptions } from "../../common/worldObject/IWorldObject";
+import { RageBaseObject } from "../baseObject/RageBaseObject";
+import { Vector3D } from "../../../common/utils/math/Vectors";
+export declare abstract class RageWorldObject extends RageBaseObject implements IWorldObject {
+    private readonly _position;
+    private readonly _dimension;
+    get position(): Vector3D;
+    get dimension(): number;
+    protected constructor(options: IWorldObjectOptions);
+}

package/dist/server/entities/ragemp/worldObject/RageWorldObject.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageWorldObject = void 0;
+const RageBaseObject_1 = require("../baseObject/RageBaseObject");
+class RageWorldObject extends RageBaseObject_1.RageBaseObject {
+    _position;
+    _dimension;
+    get position() {
+        return this._position;
+    }
+    get dimension() {
+        return this._dimension;
+    }
+    constructor(options) {
+        super(options);
+        this._position = options.position;
+        this._dimension = options.dimension;
+    }
+}
+exports.RageWorldObject = RageWorldObject;

package/dist/server/entities/ragemp/worldObject/RageWorldObjectsIterator.d.ts

@@ -0,0 +1,10 @@
+import { RageWorldObject } from "./RageWorldObject";
+import { RageBaseObjectsIterator } from "../baseObject/RageBaseObjectsIterator";
+import { IWorldObjectsIterator } from "../../common/worldObject/IWorldObjectsIterator";
+import { Vector2D, Vector3D } from "../../../common/utils/math/Vectors";
+export declare class RageWorldObjectsIterator<T extends RageWorldObject> extends RageBaseObjectsIterator<T> implements IWorldObjectsIterator<T> {
+    constructor(baseObjects: ReadonlyMap<number, T>);
+    dimension(value: number): IterableIterator<T>;
+    range2D(center: Vector2D, range: number): IterableIterator<T>;
+    range3D(center: Vector3D, range: number): IterableIterator<T>;
+}

package/dist/server/entities/ragemp/worldObject/RageWorldObjectsIterator.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageWorldObjectsIterator = void 0;
+const RageBaseObjectsIterator_1 = require("../baseObject/RageBaseObjectsIterator");
+class RageWorldObjectsIterator extends RageBaseObjectsIterator_1.RageBaseObjectsIterator {
+    constructor(baseObjects) {
+        super(baseObjects);
+    }
+    *dimension(value) {
+        for (const worldObject of this.all()) {
+            if (worldObject.dimension === value) {
+                yield worldObject;
+            }
+        }
+    }
+    *range2D(center, range) {
+        const rangeSquared = range * range;
+        for (const worldObject of this.all()) {
+            const { position } = worldObject;
+            const distanceSquared = (center.x - position.x) * (center.x - position.x) + (center.y - position.y) * (center.y - position.y);
+            if (distanceSquared <= rangeSquared) {
+                yield worldObject;
+            }
+        }
+    }
+    *range3D(center, range) {
+        const rangeSquared = range * range;
+        for (const worldObject of this.all()) {
+            const { position } = worldObject;
+            const distanceSquared = (center.x - position.x) * (center.x - position.x) +
+                (center.y - position.y) * (center.y - position.y) +
+                (center.z - position.z) * (center.z - position.z);
+            if (distanceSquared <= rangeSquared) {
+                yield worldObject;
+            }
+        }
+    }
+}
+exports.RageWorldObjectsIterator = RageWorldObjectsIterator;

package/dist/server/entities/ragemp/worldObject/RageWorldObjectsManager.d.ts

@@ -0,0 +1,9 @@
+import { IWorldObjectsManager, IWorldObjectsManagerOptions } from "../../common/worldObject/IWorldObjectsManager";
+import { RageBaseObjectsManager } from "../baseObject/RageBaseObjectsManager";
+import { RageWorldObject } from "./RageWorldObject";
+import { RageWorldObjectsIterator } from "./RageWorldObjectsIterator";
+export declare abstract class RageWorldObjectsManager<T extends RageWorldObject> extends RageBaseObjectsManager<T> implements IWorldObjectsManager<T> {
+    protected readonly _iterator: RageWorldObjectsIterator<T>;
+    get iterator(): RageWorldObjectsIterator<T>;
+    protected constructor(options: IWorldObjectsManagerOptions);
+}

package/dist/server/entities/ragemp/worldObject/RageWorldObjectsManager.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RageWorldObjectsManager = void 0;
+const RageBaseObjectsManager_1 = require("../baseObject/RageBaseObjectsManager");
+const RageWorldObjectsIterator_1 = require("./RageWorldObjectsIterator");
+class RageWorldObjectsManager extends RageBaseObjectsManager_1.RageBaseObjectsManager {
+    _iterator;
+    get iterator() {
+        return this._iterator;
+    }
+    constructor(options) {
+        super(options);
+        this._iterator = new RageWorldObjectsIterator_1.RageWorldObjectsIterator(this.baseObjects);
+    }
+}
+exports.RageWorldObjectsManager = RageWorldObjectsManager;

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "rock-mod",
+  "version": "0.0.0",
+  "description": "Rock-Mod is a powerful framework designed for creating and managing mods for Grand Theft Auto (GTA) games.",
+  "main": "index.js",
+  "scripts": {
+    "start": "npx tsx src/index.ts",
+    "build": "npm run build:server && npm run build:client",
+    "build:server": "tsc --project tsconfig.server.json",
+    "build:client": "tsc --project tsconfig.client.json",
+    "lint:check": "eslint . --ext .ts",
+    "lint:fix": "eslint . --ext .ts --fix",
+    "format:check": "prettier --check .",
+    "format:fix": "prettier --write .",
+    "type:check": "tsc --noEmit",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "prepare": "husky"
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged"
+    }
+  },
+  "lint-staged": {
+    "*.{ts,json,md}": [
+      "npm run lint:fix",
+      "npm run format:fix"
+    ]
+  },
+  "files": ["dist"],
+  "keywords": [
+    "gta"
+  ],
+  "author": "xvetal",
+  "license": "MIT",
+  "devDependencies": {
+    "@typescript-eslint/eslint-plugin": "^7.18.0",
+    "@typescript-eslint/parser": "^7.18.0",
+    "eslint": "^8.57.1",
+    "eslint-config-airbnb-typescript": "^18.0.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-import-resolver-typescript": "^3.6.3",
+    "eslint-plugin-import": "^2.30.0",
+    "eslint-plugin-prettier": "^5.2.1",
+    "husky": "^9.1.6",
+    "lint-staged": "^15.2.10",
+    "prettier": "^3.3.3",
+    "typescript": "^5.6.2"
+  }
+}