v0.0.22-alpha.0

# Conflicts:
#	server/src/index.ts
#	server/src/types.ts

.eslintrc.yaml

@@ -0,0 +1,31 @@
+env:
+  node: true
+  es6: true
+  es2019: true
+extends:
+  - 'eslint:recommended'
+  - 'plugin:@typescript-eslint/recommended'
+#  - 'prettier'
+parser: '@typescript-eslint/parser'
+parserOptions:
+  ecmaVersion: '2019'
+  sourceType: 'script'
+plugins:
+  - '@typescript-eslint'
+ignorePatterns:
+  - 'node_modules'
+rules: {
+  '@typescript-eslint/no-explicit-any': 'off',
+  '@typescript-eslint/no-unused-vars': [
+    'warn',
+    {
+      "argsIgnorePattern": '^_',
+      "varsIgnorePattern": '^_',
+      "caughtErrorsIgnorePattern": '^_'
+    }
+  ],
+  '@typescript-eslint/ban-ts-comment': 'off',
+  '@typescript-eslint/ban-types': 'off',
+  'consistent-return': 'warn',
+  'no-empty': 'off',
+}

cef/package.json

@@ -0,0 +1,23 @@
+{
+    "name": "rage-fw-cef",
+    "version": "0.0.22-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,57 @@
+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 {
+        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>> {
+        return rpc.call(eventName, args)
+    }
+
+    public triggerServer<EventName extends keyof RageFW_ICustomServerEvent>(
+        eventName: EventName,
+        ...args: _ServerEventHasArgs<EventName> extends true
+            ? [RageFW_ServerArguments<EventName>]
+            : []
+    ): Promise<RageFW_ServerReturn<EventName>> {
+        return rpc.callServer(eventName, args)
+    }
+
+    public triggerClient<EventName extends keyof RageFW_ICustomClientEvent>(
+        eventName: EventName,
+        ...args: _ClientEventHasArgs<EventName> extends true
+            ? [RageFW_ClientArguments<EventName>]
+            : []
+    ): Promise<RageFW_ClientReturn<EventName>> {
+        return rpc.callClient(eventName, args)
+    }
+}
+
+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,
+})

client/build.js

@@ -1,16 +0,0 @@
-import { build } from 'esbuild'
-import { umdWrapper } from 'esbuild-plugin-umd-wrapper'
-build({
-    entryPoints: ['./src/index.ts'],
-    bundle: true,
-    format: 'umd',
-    platform: 'node',
-    outdir: './dist',
-    plugins: [
-        umdWrapper({
-            libraryName: 'fw',
-        }),
-    ],
-}).then(() => {
-    console.log('Successfully build. Executing types build...')
-})

client/dts.config.json

@@ -1,12 +0,0 @@
-{
-  "compilationOptions": {
-    "followSymlinks": true,
-    "preferredConfigPath": "../tsconfig.json"
-  },
-  "entries": [
-    {
-      "filePath": "./src/index.ts",
-      "outFile": "./dist/index.d.ts"
-    }
-  ]
-}

client/package.json

@@ -1,20 +1,21 @@
 {
     "name": "rage-fw-client",
-    "version": "0.0.9-alpha.0",
+    "version": "0.0.22-alpha.0",
     "main": "dist/index.js",
-    "type": "module",
+    "types": "dist/src/index.d.ts",
     "files": [
         "dist/**/*"
     ],
     "scripts": {
-        "build": "node --es-module-specifier-resolution=node build.js && pnpm types",
-        "types": "dts-bundle-generator --config dts.config.json"
+        "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,31 +1,87 @@
 import rpc from 'rage-rpc'
+
+import Logger from './logger'
+
 import {
-    RageFW_ClientEventReturn,
+    _CefEventHasArgs,
+    _ClientEventHasArgs,
+    _ServerEventHasArgs,
+    RageFW_CefArgs,
+    RageFW_CefEvent,
+    RageFW_CefReturn,
     RageFW_ClientEvent,
     RageFW_ClientEventArguments,
-    RageFW_ClientServerCallback,
+    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_ClientServerEvent>(
+    public register<EventName extends RageFW_ClientEvent>(
         eventName: EventName,
-        callback: RageFW_ClientServerCallback<EventName>,
+        callback: RageFW_ClientEventCallback<EventName>,
     ): void {
-        rpc.register(eventName, callback as rpc.ProcedureListener)
+        rpc.register(eventName, data => {
+            return callback(data)
+        })
+    }
+
+    public unregister<EventName extends RageFW_ClientEvent>(
+        eventName: EventName,
+    ): void {
+        rpc.unregister(eventName)
     }
 }
 
 class Player {
-    public triggerServer<EventName extends RageFW_ClientEvent>(
+    public browser: BrowserMp | undefined
+
+    public trigger<EventName extends keyof RageFW_ICustomClientEvent>(
         eventName: EventName,
-        ...args: RageFW_ClientEventArguments<EventName>
+        ...args: _ClientEventHasArgs<EventName> extends true
+            ? [RageFW_ClientEventArguments<EventName>]
+            : []
     ): Promise<RageFW_ClientEventReturn<EventName>> {
-        return rpc.callServer(eventName, ...args)
+        return rpc.call<RageFW_ClientEventReturn<EventName>>(eventName, args)
+    }
+
+    public triggerServer<EventName extends RageFW_ClientServerEvent>(
+        eventName: 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.ts

@@ -1,24 +0,0 @@
-/// <reference types="@ragempcommunity/types-client" />
-
-import type {
-    RageFW_ICustomClientEvent,
-    RageFW_ICustomServerEvent,
-} from 'rage-fw-shared-types'
-
-export type RageFW_ClientEvent = keyof RageFW_ICustomServerEvent
-
-export type RageFW_ClientEventArguments<K extends RageFW_ClientEvent> =
-    K extends keyof RageFW_ICustomServerEvent
-        ? Parameters<RageFW_ICustomServerEvent[K]>
-        : never
-
-export type RageFW_ClientEventReturn<K extends RageFW_ClientEvent> =
-    K extends keyof RageFW_ICustomClientEvent
-        ? ReturnType<RageFW_ICustomClientEvent[K]>
-        : never
-
-export type RageFW_ClientServerEvent = keyof RageFW_ICustomClientEvent
-
-export type RageFW_ClientServerCallback<K extends RageFW_ClientServerEvent> = (
-    args: Parameters<RageFW_ICustomClientEvent[K]>,
-) => ReturnType<RageFW_ICustomClientEvent[K]>

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

@@ -0,0 +1,47 @@
+/// <reference types="@ragempcommunity/types-client" />
+
+import type { RageFW_ICustomClientEvent } from 'rage-fw-shared-types'
+
+/**
+ * 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: 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

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

client/src/types/server.ts

@@ -0,0 +1,39 @@
+/// <reference types="@ragempcommunity/types-client" />
+
+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

@@ -1,9 +1,25 @@
 {
-  "extends": "../tsconfig.json",
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "display": "Base",
+  "exclude": [
+    "node_modules"
+  ],
   "compilerOptions": {
-    "typeRoots": [
-      "@ragempcommunity/types-client"
-    ],
-    "baseUrl": "./src"
+    "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
   }
 }

client/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,
+})

lerna.json

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

package.json

@@ -1,19 +1,24 @@
 {
   "private": true,
   "scripts": {
-    "publish": "lerna publish --force-publish"
+    "publish": "pnpm build && lerna publish --force-publish",
+    "build": "lerna run build",
+    "lint": "eslint --c .eslintrc.yaml --ext .ts client/ server/ shared-types/"
   },
   "dependencies": {
+    "@microsoft/api-extractor": "^7.47.0",
     "@ragempcommunity/types-cef": "^2.1.8",
     "@ragempcommunity/types-client": "^2.1.8",
     "@ragempcommunity/types-server": "^2.1.8",
-    "dts-bundle-generator": "^9.5.1",
-    "esbuild": "^0.21.5",
-    "esbuild-plugin-umd-wrapper": "^2.0.0",
+    "@typescript-eslint/eslint-plugin": "^7.13.0",
+    "@typescript-eslint/parser": "^7.13.0",
+    "eslint": "^8.56.0",
     "lerna": "^8.1.3",
     "prettier": "^3.3.1",
     "rage-rpc": "^0.4.0",
-    "typescript": "^5.4.5"
+    "tsup": "^8.1.0",
+    "typescript": "^5.4.5",
+    "winston": "^3.13.0"
   },
   "type": "module"
 }

pnpm-workspace.yaml

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

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/build.js

@@ -1,10 +0,0 @@
-import { build } from 'esbuild'
-
-build({
-    entryPoints: ['./src/index.ts'],
-    bundle: true,
-    format: 'cjs',
-    platform: 'node',
-    target: 'node10.4',
-    outdir: './dist',
-}).then(r => console.log('Successfully build.'))

server/dts.config.json

@@ -1,12 +0,0 @@
-{
-  "compilationOptions": {
-    "followSymlinks": true,
-    "preferredConfigPath": "../tsconfig.json"
-  },
-  "entries": [
-    {
-      "filePath": "./src/index.ts",
-      "outFile": "./dist/index.d.ts"
-    }
-  ]
-}

server/package.json

@@ -1,21 +1,21 @@
 {
     "name": "rage-fw-server",
-    "version": "0.0.9-alpha.0",
+    "version": "0.0.22-alpha.0",
     "main": "dist/index.js",
-    "types": "dist/index.d.ts",
-    "type": "module",
+    "types": "dist/src/index.d.ts",
     "files": [
         "dist/**/*"
     ],
     "scripts": {
-        "build": "node --es-module-specifier-resolution=node build.js && pnpm types",
-        "types": "dts-bundle-generator --config dts.config.json"
+        "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,42 +1,121 @@
 import rpc from 'rage-rpc'
+
+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,
-} from './types.js'
+    RageFW_ServerEventCallbackCustom,
+    RageFW_ServerEventCallbackNative,
+    RageFW_ServerEventReturn,
+} from './types'
 import { nativeEvents } from './native.events'
 
 class Server {
+    private isNativeEvent(eventName: string): eventName is keyof IServerEvents {
+        return nativeEvents.includes(eventName)
+    }
+
+    private registerCustom<EventName extends keyof RageFW_ICustomServerEvent>(
+        eventName: EventName,
+        callback: RageFW_ServerEventCallbackCustom<EventName>,
+    ): void {
+        rpc.register(
+            eventName,
+            async (args: RageFW_ServerEventArguments<EventName>, info) => {
+                callback([info.player as PlayerMp, ...args])
+            },
+        )
+    }
+
+    private registerNative<EventName extends keyof IServerEvents>(
+        eventName: EventName,
+        callback: RageFW_ServerEventCallbackNative<EventName>,
+    ): void {
+        mp.events.add(
+            eventName,
+            (...args: Parameters<IServerEvents[EventName]>) =>
+                callback([...args]),
+        )
+    }
+
     public register<EventName extends RageFW_ServerEvent>(
         eventName: EventName,
         callback: RageFW_ServerEventCallback<EventName>,
     ): void {
-        if (nativeEvents.includes(eventName)) {
-            mp.events.add(eventName, callback)
+        if (this.isNativeEvent(eventName)) {
+            this.registerNative(
+                eventName,
+                callback as RageFW_ServerEventCallbackNative,
+            )
         } else {
-            rpc.register(eventName, callback as rpc.ProcedureListener)
+            this.registerCustom(
+                eventName,
+                callback as unknown as RageFW_ServerEventCallbackCustom,
+            )
         }
     }
 
     public registerMany<EventName extends RageFW_ServerEvent>(events: {
         [event in EventName]: RageFW_ServerEventCallback<event>
     }): void {
-        Object.entries(events).map(([eventName, callback]) => {
-            if (nativeEvents.includes(eventName)) {
-                mp.events.add(
-                    eventName as keyof IServerEvents,
-                    callback as (...arg: unknown[]) => void,
-                )
-            } else {
-                rpc.register(eventName, (args: unknown[]) => {
-                    return Array.isArray(args)
-                        ? (callback as (...arg: typeof args) => void)(...args)
-                        : (callback as (arg: typeof args) => void)(args)
-                })
-            }
-        })
+        Object.entries<RageFW_ServerEventCallback<EventName>>(events).map(
+            ([eventName, callback]) => {
+                if (this.isNativeEvent(eventName)) {
+                    this.registerNative(
+                        eventName,
+                        callback as RageFW_ServerEventCallbackNative,
+                    )
+                } else {
+                    this.registerCustom(
+                        eventName as keyof RageFW_ICustomServerEvent,
+                        callback as unknown as RageFW_ServerEventCallbackCustom,
+                    )
+                }
+            },
+        )
+    }
+
+    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)
     }
 }
 
@@ -44,13 +123,32 @@ class Player {
     public triggerClient<EventName extends RageFW_ClientEvent>(
         player: PlayerMp,
         eventName: EventName,
-        ...args: RageFW_ClientEventArguments<EventName>
-    ): Promise<RageFW_ClientEventReturn<EventName>> {
+        ...args: _ClientEventHasArgs<EventName> extends true
+            ? [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.ts

@@ -1,33 +0,0 @@
-/// <reference types="@ragempcommunity/types-server" />
-
-import type {
-    RageFW_ICustomServerEvent,
-    RageFW_ICustomClientEvent,
-} from 'rage-fw-shared-types'
-
-export type RageFW_ServerEvent =
-    | keyof RageFW_ICustomServerEvent
-    | keyof IServerEvents
-
-export type RageFW_ServerEventCallback<
-    K extends keyof RageFW_ICustomServerEvent | keyof IServerEvents,
-> = K extends keyof RageFW_ICustomServerEvent
-    ? (
-          player: PlayerMp,
-          ...args: Parameters<RageFW_ICustomServerEvent[K]>
-      ) => ReturnType<RageFW_ICustomServerEvent[K]>
-    : K extends keyof IServerEvents
-      ? ThisifyServerEvents[K]
-      : never
-
-export type RageFW_ClientEvent = keyof RageFW_ICustomClientEvent
-
-export type RageFW_ClientEventArguments<K extends RageFW_ClientEvent> =
-    K extends RageFW_ClientEvent
-        ? Parameters<RageFW_ICustomClientEvent[K]>
-        : never
-
-export type RageFW_ClientEventReturn<K extends RageFW_ClientEvent> =
-    K extends RageFW_ClientEvent
-        ? ReturnType<RageFW_ICustomClientEvent[K]>
-        : never

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

@@ -0,0 +1,35 @@
+/// <reference types="@ragempcommunity/types-server" />
+
+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
+
+/**
+ * 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
+
+/**
+ * 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

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

server/src/types/server.ts

@@ -0,0 +1,74 @@
+/// <reference types="@ragempcommunity/types-server" />
+
+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
+
+/**
+ * Array of arguments for an event, name of which you pass as a generic
+ * These also include system events
+ */
+export type RageFW_ServerEventArguments<K extends RageFW_ServerEvent> =
+    K extends keyof RageFW_ICustomServerEvent
+        ? Parameters<RageFW_ICustomServerEvent[K]>
+        : K extends keyof IServerEvents
+          ? Parameters<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

server/tsconfig.json

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

server/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,
+})

shared-types/package.json

@@ -1,6 +1,6 @@
 {
     "name": "rage-fw-shared-types",
-    "version": "0.0.9-alpha.0",
+    "version": "0.0.22-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.9-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"
-}