cli check for update

cef/package.json

@@ -0,0 +1,23 @@
+{
+    "name": "rage-fw-cef",
+    "version": "0.0.23-alpha.0",
+    "main": "dist/index.js",
+    "types": "dist/src/index.d.ts",
+    "files": [
+        "dist/**/*"
+    ],
+    "scripts": {
+        "build": "tsup"
+    },
+    "dependencies": {
+        "rage-rpc": "^0.4.0"
+    },
+    "peerDependencies": {
+        "@ragempcommunity/types-cef": "^2.1.8",
+        "rage-fw-shared-types": "workspace:^"
+    },
+    "keywords": [],
+    "author": "SashaGoncharov19",
+    "license": "MIT",
+    "description": "CEF side for rage-fw"
+}

cef/src/index.ts

@@ -0,0 +1,77 @@
+import rpc from 'rage-rpc'
+
+import {
+    _CefEventHasArgs,
+    _ClientEventHasArgs,
+    _ServerEventHasArgs,
+    RageFW_CefArguments,
+    RageFW_CefCallback,
+    RageFW_CefReturn,
+    RageFW_ClientArguments,
+    RageFW_ClientReturn,
+    RageFW_ICustomCefEvent,
+    RageFW_ICustomClientEvent,
+    RageFW_ICustomServerEvent,
+    RageFW_ServerArguments,
+    RageFW_ServerReturn,
+} from './types'
+
+class Cef {
+    public register<EventName extends keyof RageFW_ICustomCefEvent>(
+        eventName: EventName,
+        callback: RageFW_CefCallback<EventName>,
+    ): void {
+        if ('mp' in window) {
+            rpc.register(eventName, callback)
+        }
+    }
+
+    public trigger<EventName extends keyof RageFW_ICustomCefEvent>(
+        eventName: EventName,
+        ...args: _CefEventHasArgs<EventName> extends true
+            ? [RageFW_CefArguments<EventName>]
+            : []
+    ): Promise<RageFW_CefReturn<EventName>> {
+        if ('mp' in window) {
+            return rpc.call(eventName, args)
+        }
+
+        return Promise.reject(
+            'RageFW was started in window which not contain global variable MP!',
+        )
+    }
+
+    public triggerServer<EventName extends keyof RageFW_ICustomServerEvent>(
+        eventName: EventName,
+        ...args: _ServerEventHasArgs<EventName> extends true
+            ? [RageFW_ServerArguments<EventName>]
+            : []
+    ): Promise<RageFW_ServerReturn<EventName>> {
+        if ('mp' in window) {
+            return rpc.callServer(eventName, args)
+        }
+
+        return Promise.reject(
+            'RageFW was started in window which not contain global variable MP!',
+        )
+    }
+
+    public triggerClient<EventName extends keyof RageFW_ICustomClientEvent>(
+        eventName: EventName,
+        ...args: _ClientEventHasArgs<EventName> extends true
+            ? [RageFW_ClientArguments<EventName>]
+            : []
+    ): Promise<RageFW_ClientReturn<EventName>> {
+        if ('mp' in window) {
+            return rpc.callClient(eventName, args)
+        }
+
+        return Promise.reject(
+            'RageFW was started in window which not contain global variable MP!',
+        )
+    }
+}
+
+export const fw = {
+    event: new Cef(),
+}

cef/src/types/cef.ts

@@ -0,0 +1,39 @@
+import { RageFW_ICustomCefEvent } from 'rage-fw-shared-types'
+export { RageFW_ICustomCefEvent } from 'rage-fw-shared-types'
+
+/**
+ * Union of all available cef event names
+ * These only include custom events
+ */
+export type RageFW_CefEvent = keyof RageFW_ICustomCefEvent
+
+/**
+ * Array of arguments of an event you pass as a generic
+ * These only include custom cef events
+ */
+export type RageFW_CefArguments<K extends RageFW_CefEvent> = Parameters<
+    RageFW_ICustomCefEvent[K]
+>
+
+/**
+ * Return type of event you pass as a generic
+ * These only include custom cef events
+ */
+export type RageFW_CefReturn<K extends RageFW_CefEvent> = ReturnType<
+    RageFW_ICustomCefEvent[K]
+>
+
+/**
+ * Callback (function) of event you pass as a generic
+ * These only include custom cef events
+ */
+export type RageFW_CefCallback<K extends keyof RageFW_ICustomCefEvent> = (
+    args: RageFW_CefArguments<K>,
+) => RageFW_CefReturn<K>
+
+export type _CefEventHasArgs<EventName extends keyof RageFW_ICustomCefEvent> =
+    keyof RageFW_ICustomCefEvent extends never
+        ? false
+        : Parameters<RageFW_ICustomCefEvent[EventName]>[0] extends undefined
+          ? false
+          : true

cef/src/types/client.ts

@@ -0,0 +1,32 @@
+import type { RageFW_ICustomClientEvent } from 'rage-fw-shared-types'
+export type { RageFW_ICustomClientEvent } from 'rage-fw-shared-types'
+
+/**
+ * Union of all available client event names
+ * These only include custom events
+ */
+export type RageFW_ClientEvent = keyof RageFW_ICustomClientEvent
+
+/**
+ * Array of arguments of event you pass as a generic
+ * These only include custom client events
+ */
+export type RageFW_ClientArguments<K extends RageFW_ClientEvent> = Parameters<
+    RageFW_ICustomClientEvent[K]
+>
+
+/**
+ * Return type of event you pass as a generic
+ * These only include custom client events
+ */
+export type RageFW_ClientReturn<K extends RageFW_ClientEvent> = ReturnType<
+    RageFW_ICustomClientEvent[K]
+>
+
+export type _ClientEventHasArgs<
+    EventName extends keyof RageFW_ICustomClientEvent,
+> = keyof RageFW_ICustomClientEvent extends never
+    ? false
+    : Parameters<RageFW_ICustomClientEvent[EventName]>[0] extends undefined
+      ? false
+      : true

cef/src/types/index.ts

@@ -0,0 +1,3 @@
+export * from './cef'
+export * from './client'
+export * from './server'

cef/src/types/server.ts

@@ -0,0 +1,32 @@
+import type { RageFW_ICustomServerEvent } from 'rage-fw-shared-types'
+export type { RageFW_ICustomServerEvent } from 'rage-fw-shared-types'
+
+/**
+ * Union of all available server event names
+ * These only include custom events
+ */
+export type RageFW_ServerEvent = keyof RageFW_ICustomServerEvent
+
+/**
+ * Array of arguments of event you pass as a generic
+ * These only include custom server events
+ */
+export type RageFW_ServerArguments<K extends RageFW_ServerEvent> = Parameters<
+    RageFW_ICustomServerEvent[K]
+>
+
+/**
+ * Return type of event you pass as a generic
+ * These only include custom server events
+ */
+export type RageFW_ServerReturn<K extends RageFW_ServerEvent> = ReturnType<
+    RageFW_ICustomServerEvent[K]
+>
+
+export type _ServerEventHasArgs<
+    EventName extends keyof RageFW_ICustomServerEvent,
+> = keyof RageFW_ICustomServerEvent extends never
+    ? false
+    : Parameters<RageFW_ICustomServerEvent[EventName]>[0] extends undefined
+      ? false
+      : true

cef/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "display": "Base",
+  "exclude": [
+    "node_modules"
+  ],
+  "compilerOptions": {
+    "incremental": false,
+    "composite": false,
+    "target": "ES2022",
+    "experimentalDecorators": true,
+    "moduleDetection": "auto",
+    "module": "CommonJS",
+    "resolveJsonModule": true,
+    "declaration": false,
+    "declarationMap": false,
+    "sourceMap": false,
+    "downlevelIteration": false,
+    "inlineSourceMap": false,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true
+  }
+}

cef/tsup.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from 'tsup'
+
+export default defineConfig({
+    entry: ['src/index.ts'],
+    outDir: './dist',
+    format: ['cjs'],
+    noExternal: ['rage-rpc'],
+    experimentalDts: true,
+    splitting: false,
+    sourcemap: false,
+    clean: true,
+})

cli/.gitignore

@@ -0,0 +1,12 @@
+# build
+bin/
+
+# deps
+node_modules/
+package-lock.json
+yarn.lock
+pnpm-lock.yaml
+
+# dev
+.vscode/
+.idea/

cli/.prettierrc.yaml

@@ -0,0 +1,6 @@
+tabWidth: 4
+printWidth: 80
+singleQuote: true
+semi: false
+arrowParens: avoid
+endOfLine: auto

cli/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "rage-fw",
+  "version": "0.0.23",
+  "bin": {
+    "rage-fw": "dist/index.js"
+  },
+  "main": "dist/index.js",
+  "scripts": {
+    "watch": "tsc -w",
+    "build": "tsup",
+    "start": "npx ./dist create"
+  },
+  "description": "CLI to scaffold a template project for RageFW",
+  "keywords": [],
+  "author": "rilaxik",
+  "license": "ISC",
+  "dependencies": {
+    "@inquirer/prompts": "^5.0.5",
+    "chalk": "4.1.2",
+    "git-clone": "^0.2.0",
+    "yargs": "^17.7.2",
+    "axios": "^1.7.2"
+  },
+  "devDependencies": {
+    "@types/git-clone": "^0.2.4",
+    "@types/node": "^20.14.2",
+    "@types/yargs": "^17.0.32",
+    "prettier": "^3.3.2",
+    "typescript": "^5.4.5"
+  }
+}

cli/src/commands/create.ts

@@ -0,0 +1,67 @@
+import type { CommandModule } from 'yargs'
+import c from 'chalk'
+import { input, select } from '@inquirer/prompts'
+import clone from 'git-clone'
+import path from 'node:path'
+
+// the handler function will be called when our command is executed
+// it will receive the command line arguments parsed by yargs
+async function handler() {
+    const folder = await input({
+        message: c.gray('Enter project name:'),
+        default: 'rage-fw',
+    })
+    const framework = await select({
+        message: c.gray('Select frontend:'),
+        default: 'react',
+        loop: true,
+        choices: [
+            {
+                name: 'React + TypeScript (Vite)',
+                value: 'react',
+                description: 'React + TypeScript (Vite) as a frontend',
+            },
+            // {
+            //     name: 'vue',
+            //     value: 'vue',
+            //     description: 'npm is the most popular package manager',
+            // },
+        ],
+    })
+
+    console.log(
+        c.gray('\nScaffolding template project into'),
+        folder,
+        c.gray('with'),
+        framework,
+        c.gray('as a frontend..'),
+    )
+
+    clone(
+        'https://git.entityseven.com/entityseven/rage-framework-example',
+        path.join(__dirname, folder),
+        {},
+        err => {
+            if (err) {
+                console.log(c.red('Error occured: \n', err))
+                return
+            }
+            console.log(c.gray('Scaffolded project into'), folder)
+            console.log(
+                c.blueBright(
+                    'Working on Rage Framework. RageFW © Powered by Entity Seven Group',
+                ),
+            )
+        },
+    )
+}
+
+// name and description for our command module
+const init: CommandModule = {
+    command: 'create [template]',
+    aliases: 'c',
+    describe: 'Scaffold a template project using RageFW',
+    handler,
+}
+
+export default init

cli/src/index.ts

@@ -0,0 +1,13 @@
+import yargs from 'yargs'
+
+import create from './commands/create'
+import { checkForUpdate } from './utils/update'
+
+yargs.middleware(checkForUpdate)
+
+yargs
+    .usage('<cmd> [args]')
+    // .scriptName('rage-fw')
+    //     .usage('$0 <cmd> [args]')
+    .command(create)
+    .help().argv

cli/src/utils/update.ts

@@ -0,0 +1,28 @@
+import axios from 'axios'
+import c from 'chalk'
+import yargs from 'yargs'
+
+const latestVersionURL =
+    'https://git.entityseven.com/api/v1/repos/entityseven/rage-framework/tags?page=1&limit=1'
+
+type Version = {
+    name: string
+    message: string
+}
+
+export async function checkForUpdate() {
+    yargs.showVersion(version =>
+        axios.get<Version[]>(latestVersionURL).then(({ data }) => {
+            const latestVersion = data[0].name
+
+            if (!(latestVersion === version))
+                notifyUserAboutUpdate(latestVersion)
+
+            return
+        }),
+    )
+}
+
+function notifyUserAboutUpdate(version: string) {
+    console.log(c.green(`Update available. New version: ${version}`))
+}

cli/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "target": "es6",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "lib": ["DOM", "ES6"],
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+
+    "outDir": "bin",
+    "esModuleInterop": true,
+
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "noImplicitAny": true
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}

cli/tsup.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'tsup'
+
+export default defineConfig({
+    entry: ['src/index.ts'],
+    outDir: './dist',
+    bundle: true,
+    splitting: false,
+    sourcemap: false,
+    clean: true,
+})

client/package.json

@@ -1,8 +1,8 @@
 {
     "name": "rage-fw-client",
-    "version": "0.0.15-alpha.0",
+    "version": "0.0.23-alpha.0",
     "main": "dist/index.js",
-    "types": "dist/index.d.ts",
+    "types": "dist/src/index.d.ts",
     "files": [
         "dist/**/*"
     ],
@@ -10,10 +10,12 @@
         "build": "tsup"
     },
     "dependencies": {
-        "@ragempcommunity/types-client": "^2.1.8",
-        "rage-fw-shared-types": "workspace:^",
         "rage-rpc": "^0.4.0"
     },
+    "peerDependencies": {
+        "@ragempcommunity/types-client": "^2.1.8",
+        "rage-fw-shared-types": "workspace:^"
+    },
     "keywords": [],
     "author": "SashaGoncharov19",
     "license": "MIT",

client/src/index.ts

@@ -1,13 +1,25 @@
 import rpc from 'rage-rpc'
 
-import type {
+import Logger from './logger'
-    RageFW_ClientEventCallback,
+
+import {
+    _CefEventHasArgs,
+    _ClientEventHasArgs,
+    _ServerEventHasArgs,
+    RageFW_CefArgs,
+    RageFW_CefEvent,
+    RageFW_CefReturn,
     RageFW_ClientEvent,
+    RageFW_ClientEventArguments,
+    RageFW_ClientEventCallback,
+    RageFW_ClientEventReturn,
     RageFW_ClientServerEvent,
     RageFW_ClientServerEventArguments,
     RageFW_ClientServerEventReturn,
 } from './types'
 
+import type { RageFW_ICustomClientEvent } from 'rage-fw-shared-types'
+
 class Client {
     public register<EventName extends RageFW_ClientEvent>(
         eventName: EventName,
@@ -17,18 +29,59 @@ class Client {
             return callback(data)
         })
     }
+
+    public unregister<EventName extends RageFW_ClientEvent>(
+        eventName: EventName,
+    ): void {
+        rpc.unregister(eventName)
+    }
 }
 
 class Player {
+    public browser: BrowserMp | undefined
+
+    public trigger<EventName extends keyof RageFW_ICustomClientEvent>(
+        eventName: EventName,
+        ...args: _ClientEventHasArgs<EventName> extends true
+            ? [RageFW_ClientEventArguments<EventName>]
+            : []
+    ): Promise<RageFW_ClientEventReturn<EventName>> {
+        return rpc.call<RageFW_ClientEventReturn<EventName>>(eventName, args)
+    }
+
     public triggerServer<EventName extends RageFW_ClientServerEvent>(
         eventName: EventName,
-        args: RageFW_ClientServerEventArguments<EventName>,
+        ...args: _ServerEventHasArgs<EventName> extends true
+            ? [RageFW_ClientServerEventArguments<EventName>]
+            : []
     ): Promise<RageFW_ClientServerEventReturn<EventName>> {
         return rpc.callServer(eventName, args)
     }
+
+    public triggerBrowser<EventName extends RageFW_CefEvent>(
+        eventName: EventName,
+        ...args: _CefEventHasArgs<EventName> extends true
+            ? [RageFW_CefArgs<EventName>]
+            : []
+    ): Promise<RageFW_CefReturn<EventName>> {
+        if (!this.browser)
+            throw new Error('You need to initialize browser first!')
+        return rpc.callBrowser(this.browser, eventName, args)
+    }
+}
+
+class Browser extends Player {
+    public registerBrowser(browser: BrowserMp) {
+        this.browser = browser
+        return browser
+    }
 }
 
 export const fw = {
     event: new Client(),
     player: new Player(),
+    browser: new Browser(),
+    system: {
+        log: new Logger(),
+    },
 }

client/src/logger.ts

@@ -0,0 +1,19 @@
+export default class Logger {
+    public error(message: unknown) {
+        mp.console.logError(
+            `[${new Date().toLocaleTimeString()}] [ERROR] ${message}`,
+        )
+    }
+
+    public warn(message: unknown) {
+        mp.console.logWarning(
+            `[${new Date().toLocaleTimeString()}] [WARN] ${message}`,
+        )
+    }
+
+    public info(message: unknown) {
+        mp.console.logInfo(
+            `[${new Date().toLocaleTimeString()}] [INFO] ${message}`,
+        )
+    }
+}

client/src/types/browser.ts

@@ -0,0 +1,20 @@
+/// <reference types="@ragempcommunity/types-client" />
+
+import type { RageFW_ICustomCefEvent } from 'rage-fw-shared-types'
+
+export type RageFW_CefEvent = keyof RageFW_ICustomCefEvent
+
+export type RageFW_CefArgs<K extends RageFW_CefEvent> = Parameters<
+    RageFW_ICustomCefEvent[K]
+>
+
+export type RageFW_CefReturn<K extends RageFW_CefEvent> = ReturnType<
+    RageFW_ICustomCefEvent[K]
+>
+
+export type _CefEventHasArgs<EventName extends keyof RageFW_ICustomCefEvent> =
+    keyof RageFW_ICustomCefEvent extends never
+        ? false
+        : Parameters<RageFW_ICustomCefEvent[EventName]>[0] extends undefined
+          ? false
+          : true

client/src/types/client.ts

@@ -2,13 +2,46 @@
 
 import type { RageFW_ICustomClientEvent } from 'rage-fw-shared-types'
 
-export type RageFW_ClientEvent = keyof RageFW_ICustomClientEvent
+/**
+ * Union of all available client event names
+ * These include custom and system events
+ */
+export type RageFW_ClientEvent =
+    | keyof RageFW_ICustomClientEvent
+    | keyof IClientEvents
 
+/**
+ * Array of arguments for an event, name of which you pass as a generic
+ * These include custom and system events
+ */
+export type RageFW_ClientEventArguments<K extends RageFW_ClientEvent> =
+    K extends keyof RageFW_ICustomClientEvent
+        ? Parameters<RageFW_ICustomClientEvent[K]>
+        : K extends keyof IClientEvents
+          ? Parameters<IClientEvents[K]>
+          : never
+
+/**
+ * Callback (function) for an event, name of which you pass as a generic
+ * These only include custom events
+ */
 export type RageFW_ClientEventCallback<K extends RageFW_ClientEvent> = (
-    args: Parameters<RageFW_ICustomClientEvent[K]>,
+    args: RageFW_ClientEventArguments<K>,
 ) => RageFW_ClientEventReturn<K>
 
+/**
+ * Return type for an event, name of which you pass as a generic
+ * These only include custom events
+ */
 export type RageFW_ClientEventReturn<K extends RageFW_ClientEvent> =
     K extends keyof RageFW_ICustomClientEvent
         ? ReturnType<RageFW_ICustomClientEvent[K]>
         : never
+
+export type _ClientEventHasArgs<
+    EventName extends keyof RageFW_ICustomClientEvent,
+> = keyof RageFW_ICustomClientEvent extends never
+    ? false
+    : Parameters<RageFW_ICustomClientEvent[EventName]>[0] extends undefined
+      ? false
+      : true

client/src/types/index.ts

@@ -1,2 +1,3 @@
 export * from './client'
 export * from './server'
+export * from './browser'

client/src/types/server.ts

@@ -1,16 +1,39 @@
 /// <reference types="@ragempcommunity/types-client" />
 
-import type { RageFW_ICustomServerEvent } from 'rage-fw-shared-types'
+import type {
+    RageFW_ICustomClientEvent,
+    RageFW_ICustomServerEvent,
+} from 'rage-fw-shared-types'
 
+/**
+ * Union of all available server event names callable from client
+ * These only include custom events
+ */
 export type RageFW_ClientServerEvent = keyof RageFW_ICustomServerEvent
 
+/**
+ * Array of arguments for an event, name of which you pass as a generic
+ * These only include custom events
+ */
 export type RageFW_ClientServerEventArguments<
     K extends RageFW_ClientServerEvent,
 > = K extends keyof RageFW_ICustomServerEvent
     ? Parameters<RageFW_ICustomServerEvent[K]>
     : never
 
+/**
+ * Return type for an event, name of which you pass as a generic
+ * These only include custom events
+ */
 export type RageFW_ClientServerEventReturn<K extends RageFW_ClientServerEvent> =
     K extends keyof RageFW_ICustomServerEvent
         ? ReturnType<RageFW_ICustomServerEvent[K]>
         : never
+
+export type _ServerEventHasArgs<
+    EventName extends keyof RageFW_ICustomServerEvent,
+> = keyof RageFW_ICustomClientEvent extends never
+    ? false
+    : Parameters<RageFW_ICustomServerEvent[EventName]>[0] extends undefined
+      ? false
+      : true

client/tsconfig.json

@@ -9,7 +9,6 @@
     "composite": false,
     "target": "ES2022",
     "experimentalDecorators": true,
-    "emitDecoratorMetadata": true,
     "moduleDetection": "auto",
     "module": "CommonJS",
     "resolveJsonModule": true,

client/tsup.config.ts

@@ -5,7 +5,7 @@ export default defineConfig({
     outDir: './dist',
     format: ['cjs'],
     noExternal: ['rage-rpc'],
-    dts: true,
+    experimentalDts: true,
     splitting: false,
     sourcemap: false,
     clean: true,

lerna.json

@@ -1,5 +1,5 @@
 {
     "$schema": "node_modules/lerna/schemas/lerna-schema.json",
-    "version": "0.0.15-alpha.0",
+    "version": "0.0.23-alpha.0",
     "npmClient": "pnpm"
 }

package.json

@@ -17,10 +17,8 @@
     "prettier": "^3.3.1",
     "rage-rpc": "^0.4.0",
     "tsup": "^8.1.0",
-    "typescript": "^5.4.5"
+    "typescript": "^5.4.5",
+    "winston": "^3.13.0"
   },
-  "type": "module",
+  "type": "module"
-  "devDependencies": {
-
-  }
 }

pnpm-workspace.yaml

@@ -1,5 +1,6 @@
 packages:
   - "server"
   - "client"
-  - "shared"
+  - "cef"
+  - "cli"
   - "shared-types"

rage-rpc/README.md

@@ -0,0 +1 @@
+Currently not maintained.

rage-rpc/package.json

@@ -0,0 +1,24 @@
+{
+    "name": "rage-fw-rpc",
+    "version": "0.0.23-alpha.0",
+    "main": "dist/index.js",
+    "types": "dist/src/index.d.ts",
+    "files": [
+        "dist/**/*"
+    ],
+    "scripts": {
+        "build": "tsup"
+    },
+    "dependencies": {
+        "rage-rpc": "^0.4.0"
+    },
+    "peerDependencies": {
+        "@ragempcommunity/types-client": "^2.1.8",
+        "rage-fw-shared-types": "workspace:^"
+    },
+    "keywords": [],
+    "author": "SashaGoncharov19",
+    "license": "MIT",
+    "description": "Client side of rage-fw",
+    "gitHead": "053e4fd12aa120d53e11e0d2009c0df78c1a2ad0"
+}

rage-rpc/src/defs.d.ts

@@ -0,0 +1,42 @@
+declare var mp: any;
+declare var global: any;
+declare var window: any;
+
+declare type ProcedureListener = (args: any, info: ProcedureListenerInfo) => any;
+
+declare interface Player {
+    call: (eventName: string, args?: any[]) => void;
+    [property: string]: any;
+}
+
+declare interface Browser {
+    url: string;
+    execute: (code: string) => void;
+    [property: string]: any;
+}
+
+declare interface ProcedureListenerInfo {
+    environment: string;
+    id?: string;
+    player?: Player;
+    browser?: Browser;
+}
+
+declare interface CallOptions {
+    timeout?: number;
+    noRet?: boolean;
+}
+
+declare interface Event {
+    req?: number;
+    ret?: number;
+    b?: string;
+    id: string;
+    name?: string;
+    args?: any;
+    env: string;
+    fenv?: string;
+    res?: any;
+    err?: any;
+    noRet?: number;
+}

rage-rpc/src/index.ts

@@ -0,0 +1,568 @@
+import * as util from './util';
+
+const environment = util.getEnvironment();
+if(!environment) throw 'Unknown RAGE environment';
+
+const ERR_NOT_FOUND = 'PROCEDURE_NOT_FOUND';
+
+const IDENTIFIER = '__rpc:id';
+const PROCESS_EVENT = '__rpc:process';
+const BROWSER_REGISTER = '__rpc:browserRegister';
+const BROWSER_UNREGISTER = '__rpc:browserUnregister';
+const TRIGGER_EVENT = '__rpc:triggerEvent';
+const TRIGGER_EVENT_BROWSERS = '__rpc:triggerEventBrowsers';
+
+const glob = environment === 'cef' ? window : global;
+
+if(!glob[PROCESS_EVENT]){
+    glob.__rpcListeners = {};
+    glob.__rpcPending = {};
+    glob.__rpcEvListeners = {};
+
+    glob[PROCESS_EVENT] = (player: Player | string, rawData?: string) => {
+        if(environment !== "server") rawData = player as string;
+        const data: Event = util.parseData(rawData);
+
+        if(data.req){ // someone is trying to remotely call a procedure
+            const info: ProcedureListenerInfo = {
+                id: data.id,
+                environment: data.fenv || data.env
+            };
+            if(environment === "server") info.player = player as Player;
+            const part = {
+                ret: 1,
+                id: data.id,
+                env: environment
+            };
+            let ret: (ev: Event) => void;
+            switch(environment){
+                case "server":
+                    ret = ev => info.player.call(PROCESS_EVENT, [util.stringifyData(ev)]);
+                    break;
+                case "client": {
+                    if(data.env === "server"){
+                        ret = ev => mp.events.callRemote(PROCESS_EVENT, util.stringifyData(ev));
+                    }else if(data.env === "cef"){
+                        const browser = data.b && glob.__rpcBrowsers[data.b];
+                        info.browser = browser;
+                        ret = ev => browser && util.isBrowserValid(browser) && passEventToBrowser(browser, ev, true);
+                    }
+                    break;
+                }
+                case "cef": {
+                    ret = ev => mp.trigger(PROCESS_EVENT, util.stringifyData(ev));
+                }
+            }
+            if(ret){
+                const promise = callProcedure(data.name, data.args, info);
+                if(!data.noRet) promise.then(res => ret({ ...part, res })).catch(err => ret({ ...part, err: err ? err : null }));
+            }
+        }else if(data.ret){ // a previously called remote procedure has returned
+            const info = glob.__rpcPending[data.id];
+            if(environment === "server" && info.player !== player) return;
+            if(info){
+                info.resolve(data.hasOwnProperty('err') ? util.promiseReject(data.err) : util.promiseResolve(data.res));
+                delete glob.__rpcPending[data.id];
+            }
+        }
+    };
+
+    if(environment !== "cef"){
+        mp.events.add(PROCESS_EVENT, glob[PROCESS_EVENT]);
+
+        if(environment === "client"){
+            // set up internal pass-through events
+            register('__rpc:callServer', ([name, args, noRet], info) => _callServer(name, args, { fenv: info.environment, noRet }));
+            register('__rpc:callBrowsers', ([name, args, noRet], info) => _callBrowsers(null, name, args, { fenv: info.environment, noRet }));
+
+            // set up browser identifiers
+            glob.__rpcBrowsers = {};
+            const initBrowser = (browser: Browser): void => {
+                const id = util.uid();
+                Object.keys(glob.__rpcBrowsers).forEach(key => {
+                    const b = glob.__rpcBrowsers[key];
+                    if(!b || !util.isBrowserValid(b) || b === browser) delete glob.__rpcBrowsers[key];
+                });
+                glob.__rpcBrowsers[id] = browser;
+                browser.execute(`
+                    window.name = '${id}';
+                    if(typeof window['${IDENTIFIER}'] === 'undefined'){
+                        window['${IDENTIFIER}'] = Promise.resolve(window.name);
+                    }else{
+                        window['${IDENTIFIER}:resolve'](window.name);
+                    }
+                `);
+            };
+            mp.browsers.forEach(initBrowser);
+            mp.events.add('browserCreated', initBrowser);
+
+            // set up browser registration map
+            glob.__rpcBrowserProcedures = {};
+            mp.events.add(BROWSER_REGISTER, (data: string) => {
+                const [browserId, name] = JSON.parse(data);
+                glob.__rpcBrowserProcedures[name] = browserId;
+            });
+            mp.events.add(BROWSER_UNREGISTER, (data: string) => {
+                const [browserId, name] = JSON.parse(data);
+                if(glob.__rpcBrowserProcedures[name] === browserId) delete glob.__rpcBrowserProcedures[name];
+            });
+
+            register(TRIGGER_EVENT_BROWSERS, ([name, args], info) => {
+                Object.values(glob.__rpcBrowsers).forEach(browser => {
+                    _callBrowser(browser, TRIGGER_EVENT, [name, args], { fenv: info.environment, noRet: 1 });
+                });
+            });
+        }
+    }else{
+        if(typeof glob[IDENTIFIER] === 'undefined'){
+            glob[IDENTIFIER] = new Promise(resolve => {
+                if (window.name) {
+                    resolve(window.name);
+                }else{
+                    glob[IDENTIFIER+':resolve'] = resolve;
+                }
+            });
+        }
+    }
+
+    register(TRIGGER_EVENT, ([name, args], info) => callEvent(name, args, info));
+}
+
+function passEventToBrowser(browser: Browser, data: Event, ignoreNotFound: boolean): void {
+    const raw = util.stringifyData(data);
+    browser.execute(`var process = window["${PROCESS_EVENT}"]; if(process){ process(${JSON.stringify(raw)}); }else{ ${ignoreNotFound ? '' : `mp.trigger("${PROCESS_EVENT}", '{"ret":1,"id":"${data.id}","err":"${ERR_NOT_FOUND}","env":"cef"}');`} }`);
+}
+
+function callProcedure(name: string, args: any, info: ProcedureListenerInfo): Promise<any> {
+    const listener = glob.__rpcListeners[name];
+    if(!listener) return util.promiseReject(ERR_NOT_FOUND);
+    return util.promiseResolve(listener(args, info));
+}
+
+/**
+ * Register a procedure.
+ * @param {string} name - The name of the procedure.
+ * @param {function} cb - The procedure's callback. The return value will be sent back to the caller.
+ * @returns {Function} The function, which unregister the event.
+ */
+export function register(name: string, cb: ProcedureListener): Function {
+    if(arguments.length !== 2) throw 'register expects 2 arguments: "name" and "cb"';
+    if(environment === "cef") glob[IDENTIFIER].then((id: string) => mp.trigger(BROWSER_REGISTER, JSON.stringify([id, name])));
+    glob.__rpcListeners[name] = cb;
+
+    return () => unregister(name);
+}
+
+/**
+ * Unregister a procedure.
+ * @param {string} name - The name of the procedure.
+ */
+export function unregister(name: string): void {
+    if(arguments.length !== 1) throw 'unregister expects 1 argument: "name"';
+    if(environment === "cef") glob[IDENTIFIER].then((id: string) => mp.trigger(BROWSER_UNREGISTER, JSON.stringify([id, name])));
+    glob.__rpcListeners[name] = undefined;
+}
+
+/**
+ * Calls a local procedure. Only procedures registered in the same context will be resolved.
+ *
+ * Can be called from any environment.
+ *
+ * @param name - The name of the locally registered procedure.
+ * @param args - Any parameters for the procedure.
+ * @param options - Any options.
+ * @returns The result from the procedure.
+ */
+export function call(name: string, args?: any, options: CallOptions = {}): Promise<any> {
+    if(arguments.length < 1 || arguments.length > 3) return util.promiseReject('call expects 1 to 3 arguments: "name", optional "args", and optional "options"');
+    return util.promiseTimeout(callProcedure(name, args, { environment }), options.timeout);
+}
+
+function _callServer(name: string, args?: any, extraData: any = {}): Promise<any> {
+    switch(environment){
+        case "server": {
+            return call(name, args);
+        }
+        case "client": {
+            const id = util.uid();
+            return new Promise(resolve => {
+                if(!extraData.noRet){
+                    glob.__rpcPending[id] = {
+                        resolve
+                    };
+                }
+                const event: Event = {
+                    req: 1,
+                    id,
+                    name,
+                    env: environment,
+                    args,
+                    ...extraData
+                };
+                mp.events.callRemote(PROCESS_EVENT, util.stringifyData(event));
+            });
+        }
+        case "cef": {
+            return callClient('__rpc:callServer', [name, args, +extraData.noRet]);
+        }
+    }
+}
+
+/**
+ * Calls a remote procedure registered on the server.
+ *
+ * Can be called from any environment.
+ *
+ * @param name - The name of the registered procedure.
+ * @param args - Any parameters for the procedure.
+ * @param options - Any options.
+ * @returns The result from the procedure.
+ */
+export function callServer(name: string, args?: any, options: CallOptions = {}): Promise<any> {
+    if(arguments.length < 1 || arguments.length > 3) return util.promiseReject('callServer expects 1 to 3 arguments: "name", optional "args", and optional "options"');
+
+    let extraData: any = {};
+    if(options.noRet) extraData.noRet = 1;
+
+    return util.promiseTimeout(_callServer(name, args, extraData), options.timeout);
+}
+
+function _callClient(player: Player, name: string, args?: any, extraData: any = {}): Promise<any> {
+    switch(environment){
+        case 'client': {
+            return call(name, args);
+        }
+        case 'server': {
+            const id = util.uid();
+            return new Promise(resolve => {
+                if(!extraData.noRet){
+                    glob.__rpcPending[id] = {
+                        resolve,
+                        player
+                    };
+                }
+                const event: Event = {
+                    req: 1,
+                    id,
+                    name,
+                    env: environment,
+                    args,
+                    ...extraData
+                };
+                player.call(PROCESS_EVENT, [util.stringifyData(event)]);
+            });
+        }
+        case 'cef': {
+            const id = util.uid();
+            return glob[IDENTIFIER].then((browserId: string) => {
+                return new Promise(resolve => {
+                    if(!extraData.noRet){
+                        glob.__rpcPending[id] = {
+                            resolve
+                        };
+                    }
+                    const event: Event = {
+                        b: browserId,
+                        req: 1,
+                        id,
+                        name,
+                        env: environment,
+                        args,
+                        ...extraData
+                    };
+                    mp.trigger(PROCESS_EVENT, util.stringifyData(event));
+                });
+            });
+        }
+    }
+}
+
+/**
+ * Calls a remote procedure registered on the client.
+ *
+ * Can be called from any environment.
+ *
+ * @param player - The player to call the procedure on.
+ * @param name - The name of the registered procedure.
+ * @param args - Any parameters for the procedure.
+ * @param options - Any options.
+ * @returns The result from the procedure.
+ */
+export function callClient(player: Player | string, name?: string | any, args?: any, options: CallOptions = {}): Promise<any> {
+    switch(environment){
+        case 'client': {
+            options = args || {};
+            args = name;
+            name = player;
+            player = null;
+            if((arguments.length < 1 || arguments.length > 3) || typeof name !== 'string') return util.promiseReject('callClient from the client expects 1 to 3 arguments: "name", optional "args", and optional "options"');
+            break;
+        }
+        case 'server': {
+            if((arguments.length < 2 || arguments.length > 4) || typeof player !== 'object') return util.promiseReject('callClient from the server expects 2 to 4 arguments: "player", "name", optional "args", and optional "options"');
+            break;
+        }
+        case 'cef': {
+            options = args || {};
+            args = name;
+            name = player;
+            player = null;
+            if((arguments.length < 1 || arguments.length > 3) || typeof name !== 'string') return util.promiseReject('callClient from the browser expects 1 to 3 arguments: "name", optional "args", and optional "options"');
+            break;
+        }
+    }
+
+    let extraData: any = {};
+    if(options.noRet) extraData.noRet = 1;
+
+    return util.promiseTimeout(_callClient(player as Player, name, args, extraData), options.timeout);
+}
+
+function _callBrowser(browser: Browser, name: string, args?: any, extraData: any = {}): Promise<any> {
+    return new Promise(resolve => {
+        const id = util.uid();
+        if(!extraData.noRet){
+            glob.__rpcPending[id] = {
+                resolve
+            };
+        }
+        passEventToBrowser(browser, {
+            req: 1,
+            id,
+            name,
+            env: environment,
+            args,
+            ...extraData
+        }, false);
+    });
+}
+
+function _callBrowsers(player: Player, name: string, args?: any, extraData: any = {}): Promise<any> {
+    switch(environment){
+        case 'client':
+            const browserId = glob.__rpcBrowserProcedures[name];
+            if(!browserId) return util.promiseReject(ERR_NOT_FOUND);
+            const browser = glob.__rpcBrowsers[browserId];
+            if(!browser || !util.isBrowserValid(browser)) return util.promiseReject(ERR_NOT_FOUND);
+            return _callBrowser(browser, name, args, extraData);
+        case 'server':
+            return _callClient(player, '__rpc:callBrowsers', [name, args, +extraData.noRet], extraData);
+        case 'cef':
+            return _callClient(null, '__rpc:callBrowsers', [name, args, +extraData.noRet], extraData);
+    }
+}
+
+/**
+ * Calls a remote procedure registered in any browser context.
+ *
+ * Can be called from any environment.
+ *
+ * @param player - The player to call the procedure on.
+ * @param name - The name of the registered procedure.
+ * @param args - Any parameters for the procedure.
+ * @param options - Any options.
+ * @returns The result from the procedure.
+ */
+export function callBrowsers(player: Player | string, name?: string | any, args?: any, options: CallOptions = {}): Promise<any> {
+    let promise;
+    let extraData: any = {};
+
+    switch(environment){
+        case 'client':
+        case 'cef':
+            options = args || {};
+            args = name;
+            name = player;
+            if(arguments.length < 1 || arguments.length > 3) return util.promiseReject('callBrowsers from the client or browser expects 1 to 3 arguments: "name", optional "args", and optional "options"');
+            if(options.noRet) extraData.noRet = 1;
+            promise = _callBrowsers(null, name, args, extraData);
+            break;
+        case 'server':
+            if(arguments.length < 2 || arguments.length > 4) return util.promiseReject('callBrowsers from the server expects 2 to 4 arguments: "player", "name", optional "args", and optional "options"');
+            if(options.noRet) extraData.noRet = 1;
+            promise = _callBrowsers(player as Player, name, args, extraData);
+            break;
+    }
+
+    if(promise){
+        return util.promiseTimeout(promise, options.timeout);
+    }
+}
+
+/**
+ * Calls a remote procedure registered in a specific browser instance.
+ *
+ * Client-side environment only.
+ *
+ * @param browser - The browser instance.
+ * @param name - The name of the registered procedure.
+ * @param args - Any parameters for the procedure.
+ * @param options - Any options.
+ * @returns The result from the procedure.
+ */
+export function callBrowser(browser: Browser, name: string, args?: any, options: CallOptions = {}): Promise<any> {
+    if(environment !== 'client') return util.promiseReject('callBrowser can only be used in the client environment');
+    if(arguments.length < 2 || arguments.length > 4) return util.promiseReject('callBrowser expects 2 to 4 arguments: "browser", "name", optional "args", and optional "options"');
+
+    let extraData: any = {};
+    if(options.noRet) extraData.noRet = 1;
+
+    return util.promiseTimeout(_callBrowser(browser, name, args, extraData), options.timeout);
+}
+
+function callEvent(name: string, args: any, info: ProcedureListenerInfo){
+    const listeners = glob.__rpcEvListeners[name];
+    if(listeners){
+        listeners.forEach(listener => listener(args, info));
+    }
+}
+
+/**
+ * Register an event handler.
+ * @param {string} name - The name of the event.
+ * @param cb - The callback for the event.
+ * @returns {Function} The function, which off the event.
+ */
+export function on(name: string, cb: ProcedureListener): Function {
+    if(arguments.length !== 2) throw 'on expects 2 arguments: "name" and "cb"';
+
+    const listeners = glob.__rpcEvListeners[name] || new Set();
+    listeners.add(cb);
+    glob.__rpcEvListeners[name] = listeners;
+
+    return () => off(name, cb);
+}
+
+/**
+ * Unregister an event handler.
+ * @param {string} name - The name of the event.
+ * @param cb - The callback for the event.
+ */
+export function off(name: string, cb: ProcedureListener){
+    if(arguments.length !== 2) throw 'off expects 2 arguments: "name" and "cb"';
+
+    const listeners = glob.__rpcEvListeners[name];
+    if(listeners){
+        listeners.delete(cb);
+    }
+}
+
+/**
+ * Triggers a local event. Only events registered in the same context will be triggered.
+ *
+ * Can be called from any environment.
+ *
+ * @param name - The name of the locally registered event.
+ * @param args - Any parameters for the event.
+ */
+export function trigger(name: string, args?: any){
+    if(arguments.length < 1 || arguments.length > 2) throw 'trigger expects 1 or 2 arguments: "name", and optional "args"';
+    callEvent(name, args, { environment });
+}
+
+/**
+ * Triggers an event registered on the client.
+ *
+ * Can be called from any environment.
+ *
+ * @param player - The player to call the procedure on.
+ * @param name - The name of the event.
+ * @param args - Any parameters for the event.
+ */
+export function triggerClient(player: Player | string, name?: string | any, args?: any){
+    switch(environment){
+        case 'client': {
+            args = name;
+            name = player;
+            player = null;
+            if((arguments.length < 1 || arguments.length > 2) || typeof name !== 'string') throw 'triggerClient from the client expects 1 or 2 arguments: "name", and optional "args"';
+            break;
+        }
+        case 'server': {
+            if((arguments.length < 2 || arguments.length > 3) || typeof player !== 'object') throw 'triggerClient from the server expects 2 or 3 arguments: "player", "name", and optional "args"';
+            break;
+        }
+        case 'cef': {
+            args = name;
+            name = player;
+            player = null;
+            if((arguments.length < 1 || arguments.length > 2) || typeof name !== 'string') throw 'triggerClient from the browser expects 1 or 2 arguments: "name", and optional "args"';
+            break;
+        }
+    }
+
+    _callClient(player as Player, TRIGGER_EVENT, [name, args], { noRet: 1 });
+}
+
+/**
+ * Triggers an event registered on the server.
+ *
+ * Can be called from any environment.
+ *
+ * @param name - The name of the event.
+ * @param args - Any parameters for the event.
+ */
+export function triggerServer(name: string, args?: any){
+    if(arguments.length < 1 || arguments.length > 2) throw 'triggerServer expects 1 or 2 arguments: "name", and optional "args"';
+
+    _callServer(TRIGGER_EVENT, [name, args], { noRet: 1 });
+}
+
+/**
+ * Triggers an event registered in any browser context.
+ *
+ * Can be called from any environment.
+ *
+ * @param player - The player to call the procedure on.
+ * @param name - The name of the event.
+ * @param args - Any parameters for the event.
+ */
+export function triggerBrowsers(player: Player | string, name?: string | any, args?: any){
+    switch(environment){
+        case 'client':
+        case 'cef':
+            args = name;
+            name = player;
+            player = null;
+            if(arguments.length < 1 || arguments.length > 2) throw 'triggerBrowsers from the client or browser expects 1 or 2 arguments: "name", and optional "args"';
+            break;
+        case 'server':
+            if(arguments.length < 2 || arguments.length > 3) throw 'triggerBrowsers from the server expects 2 or 3 arguments: "player", "name", and optional "args"';
+            break;
+    }
+
+    _callClient(player as Player, TRIGGER_EVENT_BROWSERS, [name, args], { noRet: 1 });
+}
+
+/**
+ * Triggers an event registered in a specific browser instance.
+ *
+ * Client-side environment only.
+ *
+ * @param browser - The browser instance.
+ * @param name - The name of the event.
+ * @param args - Any parameters for the event.
+ */
+export function triggerBrowser(browser: Browser, name: string, args?: any){
+    if(environment !== 'client') throw 'callBrowser can only be used in the client environment';
+    if(arguments.length < 2 || arguments.length > 4) throw 'callBrowser expects 2 or 3 arguments: "browser", "name", and optional "args"';
+
+    _callBrowser(browser, TRIGGER_EVENT, [name, args], { noRet: 1});
+}
+
+export default {
+    register,
+    unregister,
+    call,
+    callServer,
+    callClient,
+    callBrowsers,
+    callBrowser,
+    on,
+    off,
+    trigger,
+    triggerServer,
+    triggerClient,
+    triggerBrowsers,
+    triggerBrowser
+};

rage-rpc/src/util.ts

@@ -0,0 +1,122 @@
+enum MpTypes {
+    Blip = 'b',
+    Checkpoint = 'cp',
+    Colshape = 'c',
+    Label = 'l',
+    Marker = 'm',
+    Object = 'o',
+    Pickup = 'p',
+    Player = 'pl',
+    Vehicle = 'v'
+}
+
+function isObjectMpType(obj: any, type: MpTypes){
+    const client = getEnvironment() === 'client';
+    if(obj && typeof obj === 'object' && typeof obj.id !== 'undefined'){
+        const test = (type, collection, mpType) => client ? obj.type === type && collection.at(obj.id) === obj : obj instanceof mpType;
+        switch(type){
+            case MpTypes.Blip: return test('blip', mp.blips, mp.Blip);
+            case MpTypes.Checkpoint: return test('checkpoint', mp.checkpoints, mp.Checkpoint);
+            case MpTypes.Colshape: return test('colshape', mp.colshapes, mp.Colshape);
+            case MpTypes.Label: return test('textlabel', mp.labels, mp.TextLabel);
+            case MpTypes.Marker: return test('marker', mp.markers, mp.Marker);
+            case MpTypes.Object: return test('object', mp.objects, mp.Object);
+            case MpTypes.Pickup: return test('pickup', mp.pickups, mp.Pickup);
+            case MpTypes.Player: return test('player', mp.players, mp.Player);
+            case MpTypes.Vehicle: return test('vehicle', mp.vehicles, mp.Vehicle);
+        }
+    }
+    return false;
+}
+
+export function uid(): string {
+    const first = (Math.random() * 46656) | 0;
+    const second = (Math.random() * 46656) | 0;
+    const firstPart = ('000' + first.toString(36)).slice(-3);
+    const secondPart = ('000' + second.toString(36)).slice(-3);
+    return firstPart + secondPart;
+}
+
+export function getEnvironment(): string {
+    if ('mp' in window) return 'cef';
+    if (mp.joaat) return 'server';
+    else if (mp.game && mp.game.joaat) return 'client';
+}
+
+export function stringifyData(data: any): string {
+    const env = getEnvironment();
+    return JSON.stringify(data, (_, value) => {
+        if(env === 'client' || env === 'server' && value && typeof value === 'object'){
+            let type;
+
+            if(isObjectMpType(value, MpTypes.Blip)) type = MpTypes.Blip;
+            else if(isObjectMpType(value, MpTypes.Checkpoint)) type = MpTypes.Checkpoint;
+            else if(isObjectMpType(value, MpTypes.Colshape)) type = MpTypes.Colshape;
+            else if(isObjectMpType(value, MpTypes.Marker)) type = MpTypes.Marker;
+            else if(isObjectMpType(value, MpTypes.Object)) type = MpTypes.Object;
+            else if(isObjectMpType(value, MpTypes.Pickup)) type = MpTypes.Pickup;
+            else if(isObjectMpType(value, MpTypes.Player)) type = MpTypes.Player;
+            else if(isObjectMpType(value, MpTypes.Vehicle)) type = MpTypes.Vehicle;
+
+            if(type) return {
+                __t: type,
+                i: typeof value.remoteId === 'number' ? value.remoteId : value.id
+            };
+        }
+
+        return value;
+    });
+}
+
+export function parseData(data: string): any {
+    const env = getEnvironment();
+    return JSON.parse(data, (_, value) => {
+        if((env === 'client' || env === 'server') && value && typeof value === 'object' && typeof value['__t'] === 'string' && typeof value.i === 'number' && Object.keys(value).length === 2){
+            const id = value.i;
+            const type = value['__t'];
+            let collection;
+
+            switch(type){
+                case MpTypes.Blip: collection = mp.blips; break;
+                case MpTypes.Checkpoint: collection = mp.checkpoints; break;
+                case MpTypes.Colshape: collection = mp.colshapes; break;
+                case MpTypes.Label: collection = mp.labels; break;
+                case MpTypes.Marker: collection = mp.markers; break;
+                case MpTypes.Object: collection = mp.objects; break;
+                case MpTypes.Pickup: collection = mp.pickups; break;
+                case MpTypes.Player: collection = mp.players; break;
+                case MpTypes.Vehicle: collection = mp.vehicles; break;
+            }
+
+            if(collection) return collection[env === 'client' ? 'atRemoteId' : 'at'](id);
+        }
+
+        return value;
+    });
+}
+
+export function promiseResolve(result: any): Promise<any> {
+    return new Promise(resolve => setTimeout(() => resolve(result), 0));
+}
+
+export function promiseReject(error: any): Promise<any> {
+    return new Promise((_, reject) => setTimeout(() => reject(error), 0));
+}
+
+export function promiseTimeout(promise: Promise<any>, timeout?: number){
+    if(typeof timeout === 'number'){
+        return Promise.race([
+            new Promise((_, reject) => {
+                setTimeout(() => reject('TIMEOUT'), timeout);
+            }),
+            promise
+        ]);
+    }else return promise;
+}
+
+export function isBrowserValid(browser: Browser): boolean {
+    try {
+        browser.url;
+    }catch(e){ return false; }
+    return true;
+}

rage-rpc/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "display": "Base",
+  "exclude": [
+    "node_modules"
+  ],
+  "compilerOptions": {
+    "incremental": false,
+    "composite": false,
+    "target": "ES2022",
+    "experimentalDecorators": true,
+    "moduleDetection": "auto",
+    "module": "CommonJS",
+    "resolveJsonModule": true,
+    "declaration": false,
+    "declarationMap": false,
+    "sourceMap": false,
+    "downlevelIteration": false,
+    "inlineSourceMap": false,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true
+  }
+}

rage-rpc/tsup.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from 'tsup'
+
+export default defineConfig({
+    entry: ['src/index.ts'],
+    outDir: './dist',
+    format: ['cjs'],
+    noExternal: ['rage-rpc'],
+    experimentalDts: true,
+    splitting: false,
+    sourcemap: false,
+    clean: true,
+})

readme.md

@@ -0,0 +1,20 @@
+# Rage Framework (RageFW)
+RageFW is a type-safe framework for developing Rage:MP servers. Designed with developers in mind, RageFW brings structure and efficiency to your Rage:MP servers, ensuring robust and maintainable code
+
+## Features
+ - **Type-Safe Development:** Eliminate runtime errors and enhance code reliability with RageFW comprehensive type safety, making your RP server's development smoother than a Sunday drive through Los Santos
+
+ - **Wrapped RPC client:** Communicate effortlessly between server, client and cef with RPC system, wrapped in a cozy custom-typed blanket for your peace of mind
+
+ - **Logging System:** Keep track of server activities and debug like a pro with our built-in, feature-rich logging system. After all, even virtual cops need evidence
+
+## Getting Started
+*soon*
+
+## Contributing
+Join our community of developers and contribute to the ongoing development of RageFW. At the moment the only way to contribute is opening issues 
+
+## Support
+Need help? Reach out via our community forums or contact us directly through our support channels. We're committed to help you as we can
+
+> *RageFW - because in the world of GTA:RP, nobody has time for type errors*

server/package.json

@@ -1,6 +1,6 @@
 {
     "name": "rage-fw-server",
-    "version": "0.0.15-alpha.0",
+    "version": "0.0.23-alpha.0",
     "main": "dist/index.js",
     "types": "dist/src/index.d.ts",
     "files": [
@@ -10,10 +10,12 @@
         "build": "tsup"
     },
     "dependencies": {
-        "@ragempcommunity/types-server": "^2.1.8",
-        "rage-fw-shared-types": "workspace:^",
         "rage-rpc": "^0.4.0"
     },
+    "peerDependencies": {
+        "@ragempcommunity/types-server": "^2.1.8",
+        "rage-fw-shared-types": "workspace:^"
+    },
     "keywords": [],
     "author": "SashaGoncharov19",
     "license": "MIT",

server/src/index.ts

@@ -1,14 +1,24 @@
 import rpc from 'rage-rpc'
 
-import type {
+import Logger from './logger'
+
+import {
+    _CefEventHasArgs,
+    _ClientEventHasArgs,
+    _ServerEventHasArgs,
+    RageFW_CefArgs,
+    RageFW_CefEvent,
+    RageFW_CefReturn,
     RageFW_ClientEvent,
-    RageFW_ClientEventArguments,
-    RageFW_ClientEventReturn,
     RageFW_ICustomServerEvent,
+    RageFW_ServerClientEventArguments,
+    RageFW_ServerClientEventReturn,
     RageFW_ServerEvent,
+    RageFW_ServerEventArguments,
     RageFW_ServerEventCallback,
     RageFW_ServerEventCallbackCustom,
     RageFW_ServerEventCallbackNative,
+    RageFW_ServerEventReturn,
 } from './types'
 import { nativeEvents } from './native.events'
 
@@ -23,11 +33,8 @@ class Server {
     ): void {
         rpc.register(
             eventName,
-            async (
+            async (args: RageFW_ServerEventArguments<EventName>, info) => {
-                args: Parameters<RageFW_ICustomServerEvent[EventName]>,
+                callback([info.player as PlayerMp, ...args])
-                info,
-            ) => {
-                callback(info.player as PlayerMp, args)
             },
         )
     }
@@ -36,7 +43,11 @@ class Server {
         eventName: EventName,
         callback: RageFW_ServerEventCallbackNative<EventName>,
     ): void {
-        mp.events.add(eventName, callback)
+        mp.events.add(
+            eventName,
+            (...args: Parameters<IServerEvents[EventName]>) =>
+                callback([...args]),
+        )
     }
 
     public register<EventName extends RageFW_ServerEvent>(
@@ -75,19 +86,69 @@ class Server {
             },
         )
     }
+
+    private unregisterCustom<EventName extends keyof RageFW_ICustomServerEvent>(
+        eventName: EventName,
+    ): void {
+        rpc.unregister(eventName)
+    }
+
+    private unregisterNative<EventName extends keyof IServerEvents>(
+        eventName: EventName,
+    ): void {
+        mp.events.remove(eventName)
+    }
+
+    public unregister<EventName extends RageFW_ServerEvent>(
+        eventName: EventName,
+    ): void {
+        if (this.isNativeEvent(eventName)) {
+            this.unregisterNative(eventName)
+        } else {
+            this.unregisterCustom(eventName)
+        }
+    }
+
+    public trigger<EventName extends keyof RageFW_ICustomServerEvent>(
+        eventName: EventName,
+        ...args: _ServerEventHasArgs<EventName> extends true
+            ? [RageFW_ServerEventArguments<EventName>]
+            : []
+    ): Promise<RageFW_ServerEventReturn<EventName>> {
+        return rpc.call<RageFW_ServerEventReturn<EventName>>(eventName, args)
+    }
 }
 
 class Player {
     public triggerClient<EventName extends RageFW_ClientEvent>(
         player: PlayerMp,
         eventName: EventName,
-        args: RageFW_ClientEventArguments<EventName>,
+        ...args: _ClientEventHasArgs<EventName> extends true
-    ): Promise<RageFW_ClientEventReturn<EventName>> {
+            ? [RageFW_ServerClientEventArguments<EventName>]
+            : []
+    ): Promise<RageFW_ServerClientEventReturn<EventName>> {
         return rpc.callClient(player, eventName, args)
     }
+
+    public triggerBrowser<EventName extends RageFW_CefEvent>(
+        player: PlayerMp,
+        eventName: EventName,
+        ...args: _CefEventHasArgs<EventName> extends true
+            ? [RageFW_CefArgs<EventName>]
+            : []
+    ): Promise<RageFW_CefReturn<EventName>> {
+        return rpc.callBrowsers(player, eventName, args)
+    }
 }
 
 export const fw = {
     event: new Server(),
     player: new Player(),
+    system: {
+        log: new Logger(),
+    },
 }
+
+fw.system.log.info(
+    'Working on Rage Framework. RageFW © Powered by Entity Seven Group',
+)

server/src/logger.ts

@@ -0,0 +1,36 @@
+import winston, { format } from 'winston'
+const { timestamp, printf, colorize } = format
+
+export default class Logger {
+    private format = printf(({ message, level, timestamp }) => {
+        return `[${new Date(timestamp).toLocaleTimeString()}] [${level}]: ${message}`
+    })
+
+    private systemLogger = winston.createLogger({
+        transports: [new winston.transports.Console()],
+        format: format.combine(
+            colorize({
+                level: true,
+                colors: {
+                    error: 'red',
+                    warn: 'yellow',
+                    info: 'white',
+                },
+            }),
+            timestamp(),
+            this.format,
+        ),
+    })
+
+    public info(message: unknown) {
+        this.systemLogger.info(message)
+    }
+
+    public warn(message: unknown) {
+        this.systemLogger.warn(message)
+    }
+
+    public error(message: unknown) {
+        this.systemLogger.error(message)
+    }
+}

server/src/types/browser.ts

@@ -0,0 +1,18 @@
+import type { RageFW_ICustomCefEvent } from 'rage-fw-shared-types'
+
+export type RageFW_CefEvent = keyof RageFW_ICustomCefEvent
+
+export type RageFW_CefArgs<K extends RageFW_CefEvent> = Parameters<
+    RageFW_ICustomCefEvent[K]
+>
+
+export type RageFW_CefReturn<K extends RageFW_CefEvent> = ReturnType<
+    RageFW_ICustomCefEvent[K]
+>
+
+export type _CefEventHasArgs<EventName extends keyof RageFW_ICustomCefEvent> =
+    keyof RageFW_ICustomCefEvent extends never
+        ? false
+        : Parameters<RageFW_ICustomCefEvent[EventName]>[0] extends undefined
+          ? false
+          : true

server/src/types/client.ts

@@ -2,14 +2,34 @@
 
 import type { RageFW_ICustomClientEvent } from 'rage-fw-shared-types'
 
+/**
+ * Union of all available client event names
+ * These only include custom events
+ */
 export type RageFW_ClientEvent = keyof RageFW_ICustomClientEvent
 
-export type RageFW_ClientEventArguments<K extends RageFW_ClientEvent> =
+/**
+ * Array of arguments of an event you pass as a generic
+ * These only include custom events
+ */
+export type RageFW_ServerClientEventArguments<K extends RageFW_ClientEvent> =
     K extends RageFW_ClientEvent
         ? Parameters<RageFW_ICustomClientEvent[K]>
         : never
 
-export type RageFW_ClientEventReturn<K extends RageFW_ClientEvent> =
+/**
+ * Return type of event you pass as a generic
+ * These only include custom events
+ */
+export type RageFW_ServerClientEventReturn<K extends RageFW_ClientEvent> =
     K extends RageFW_ClientEvent
         ? ReturnType<RageFW_ICustomClientEvent[K]>
         : never
+
+export type _ClientEventHasArgs<
+    EventName extends keyof RageFW_ICustomClientEvent,
+> = keyof RageFW_ICustomClientEvent extends never
+    ? false
+    : Parameters<RageFW_ICustomClientEvent[EventName]>[0] extends undefined
+      ? false
+      : true

server/src/types/index.ts

@@ -1,2 +1,3 @@
 export * from './client'
 export * from './server'
+export * from './browser'

server/src/types/server.ts

@@ -1,26 +1,74 @@
 /// <reference types="@ragempcommunity/types-server" />
 
-import type { RageFW_ICustomServerEvent } from 'rage-fw-shared-types'
+import type {
+    RageFW_ICustomClientEvent,
+    RageFW_ICustomServerEvent,
+} from 'rage-fw-shared-types'
 export type { RageFW_ICustomServerEvent } from 'rage-fw-shared-types'
 
+/**
+ * Union of all available server event names
+ * These also include system events
+ */
 export type RageFW_ServerEvent =
     | keyof RageFW_ICustomServerEvent
     | keyof IServerEvents
 
-export type RageFW_ServerEventCallbackCustom<
+/**
-    K extends keyof RageFW_ICustomServerEvent = keyof RageFW_ICustomServerEvent,
+ * Array of arguments for an event, name of which you pass as a generic
-> = (
+ * These also include system events
-    player: PlayerMp,
+ */
-    args: Parameters<RageFW_ICustomServerEvent[K]>,
+export type RageFW_ServerEventArguments<K extends RageFW_ServerEvent> =
-) => ReturnType<RageFW_ICustomServerEvent[K]>
+    K extends keyof RageFW_ICustomServerEvent
-
+        ? Parameters<RageFW_ICustomServerEvent[K]>
-export type RageFW_ServerEventCallbackNative<
+        : K extends keyof IServerEvents
-    K extends keyof IServerEvents = keyof IServerEvents,
+          ? Parameters<IServerEvents[K]>
-> = IServerEvents[K]
+          : never
 
+/**
+ * Callback (function) for an event, name of which you pass as a generic
+ * These include system and custom events
+ */
 export type RageFW_ServerEventCallback<K extends RageFW_ServerEvent> =
     K extends keyof RageFW_ICustomServerEvent
         ? RageFW_ServerEventCallbackCustom<K>
         : K extends keyof IServerEvents
           ? RageFW_ServerEventCallbackNative<K>
           : never
+
+/**
+ * Return type for an event, name of which you pass as a generic
+ * These include system and custom events
+ */
+export type RageFW_ServerEventReturn<K extends RageFW_ServerEvent> =
+    K extends keyof RageFW_ICustomServerEvent
+        ? ReturnType<RageFW_ICustomServerEvent[K]>
+        : K extends keyof IServerEvents
+          ? ReturnType<IServerEvents[K]>
+          : never
+
+/**
+ * Array of arguments for an event, name of which you pass as a generic
+ * These only include custom events
+ */
+export type RageFW_ServerEventCallbackCustom<
+    K extends keyof RageFW_ICustomServerEvent = keyof RageFW_ICustomServerEvent,
+> = (
+    payload: [player: PlayerMp, ...args: RageFW_ServerEventArguments<K>],
+) => RageFW_ServerEventReturn<K>
+
+/**
+ * Array of arguments for an event, name of which you pass as a generic
+ * These only include system events
+ */
+export type RageFW_ServerEventCallbackNative<
+    K extends keyof IServerEvents = keyof IServerEvents,
+> = (payload: Parameters<IServerEvents[K]>) => ReturnType<IServerEvents[K]>
+
+export type _ServerEventHasArgs<
+    EventName extends keyof RageFW_ICustomServerEvent,
+> = keyof RageFW_ICustomClientEvent extends never
+    ? false
+    : Parameters<RageFW_ICustomServerEvent[EventName]>[0] extends undefined
+      ? false
+      : true

shared-types/package.json

@@ -1,6 +1,6 @@
 {
     "name": "rage-fw-shared-types",
-    "version": "0.0.15-alpha.0",
+    "version": "0.0.23-alpha.0",
     "types": "types/types/index.d.ts",
     "files": [
         "types/**/*"

shared-types/types/types/index.d.ts

@@ -2,4 +2,6 @@ declare module 'rage-fw-shared-types' {
     export interface RageFW_ICustomServerEvent {}
 
     export interface RageFW_ICustomClientEvent {}
+
+    export interface RageFW_ICustomCefEvent {}
 }

shared/package.json

@@ -1,17 +0,0 @@
-{
-    "name": "rage-fw-shared",
-    "version": "0.0.15-alpha.0",
-    "type": "module",
-    "main": "index.d.ts",
-    "files": [
-        "index.d.ts"
-    ],
-    "scripts": {
-        "test": "tsup"
-    },
-    "keywords": [],
-    "author": "SashaGoncharov19",
-    "license": "MIT",
-    "description": "Shared client types for rage-fw",
-    "gitHead": "053e4fd12aa120d53e11e0d2009c0df78c1a2ad0"
-}

tsconfig.json

@@ -1,7 +1,11 @@
 {
   "compilerOptions": {
     "target": "ESNext",
-    "lib": ["ESNext","ES2019"],
+    "lib": [
+      "ESNext",
+      "ES2019",
+      "dom"
+    ],
     "moduleResolution": "node",
     "module": "ESNext",
     "esModuleInterop": true,