@nativewrappers/common 0.0.60 → 0.0.62

package/Command.d.ts

@@ -0,0 +1,30 @@
+type Restricted = boolean | string | string[];
+interface ParameterTypes {
+    number: number;
+    playerId: number;
+    string: string;
+    longString: string;
+}
+interface Parameter {
+    name: string;
+    type: keyof ParameterTypes;
+    help?: string;
+    optional?: boolean;
+}
+type MappedParameters<T extends Parameter[]> = {
+    [K in T[number] as K["name"]]: ParameterTypes[K["type"]];
+} & {
+    source: number;
+    raw: string;
+};
+type CommandHandler<T extends Parameter[]> = (args: MappedParameters<T>) => void | Promise<void>;
+export declare class Command<T extends Parameter[] = Parameter[]> {
+    #private;
+    readonly name: string | string[];
+    readonly help: string;
+    readonly params?: T | undefined;
+    constructor(name: string | string[], help: string, handler: CommandHandler<T>, params?: T | undefined, restricted?: Restricted);
+    private mapArguments;
+    call(source: number, args: string[], raw?: string): Promise<void>;
+}
+export {};

package/Command.js

@@ -0,0 +1,89 @@
+import { GlobalData } from "./GlobalData";
+const commands = [];
+if (GlobalData.IS_SERVER) {
+    on("playerJoining", () => emitNet("chat:addSuggestions", source, commands));
+}
+export class Command {
+    name;
+    help;
+    params;
+    #handler;
+    constructor(name, help, handler, params, restricted = true) {
+        this.name = name;
+        this.help = help;
+        this.params = params;
+        const commandHandler = (source, args, raw) => this.call(source, args, raw);
+        this.#handler = handler;
+        this.name = `/${name}`;
+        typeof name === "string"
+            ? RegisterCommand(name, commandHandler, !!restricted)
+            : name.forEach((name) => RegisterCommand(name, commandHandler, !!restricted));
+        if (params) {
+            params.forEach((param) => {
+                if (param.type)
+                    param.help = param.help
+                        ? `${param.help} (type: ${param.type})`
+                        : `(type: ${param.type})`;
+            });
+            setTimeout(() => {
+                if (GlobalData.IS_SERVER) {
+                    commands.push(this);
+                    return emitNet("chat:addSuggestions", -1, this);
+                }
+                emit("chat:addSuggestion", this);
+            }, 100);
+        }
+    }
+    mapArguments(source, args, raw) {
+        const mapped = {
+            source,
+            raw,
+        };
+        if (!this.params)
+            return mapped;
+        const result = this.params.every((param, index) => {
+            const arg = args[index];
+            let value = arg;
+            switch (param.type) {
+                case "number":
+                    value = +arg;
+                    break;
+                case "string":
+                    value = !Number(arg) ? arg : false;
+                    break;
+                case "playerId":
+                    if (GlobalData.IS_SERVER) {
+                        value = arg === "me" ? source : +arg;
+                        if (!value || !DoesPlayerExist(value.toString()))
+                            value = undefined;
+                    }
+                    else {
+                        value = arg === "me" ? GetPlayerServerId(PlayerId()) : +arg;
+                        if (!value || GetPlayerFromServerId(value) === -1)
+                            value = undefined;
+                    }
+                    break;
+                case "longString":
+                    value = raw.substring(raw.indexOf(arg));
+                    break;
+            }
+            if (value === undefined && (!param.optional || (param.optional && arg))) {
+                return Citizen.trace(`^1command '${raw.split(" ")[0] || raw}' received an invalid ${param.type} for argument ${index + 1} (${param.name}), received '${arg}'^0`);
+            }
+            mapped[param.name] = value;
+            return true;
+        });
+        return result ? mapped : null;
+    }
+    async call(source, args, raw = args.join(" ")) {
+        const parsed = this.mapArguments(source, args, raw);
+        if (!parsed)
+            return;
+        try {
+            await this.#handler(parsed);
+        }
+        catch (err) {
+            Citizen.trace(`^1command '${raw.split(" ")[0] || raw}' failed to execute!^0\n${err.message}`);
+        }
+    }
+}

package/index.d.ts

@@ -2,6 +2,7 @@ export * from "./utils";
 export * from "./net/NetworkedMap";
 export * from "./decors/Events";
 export * from "./Convar";
+export * from "./Command";
 export * from "./Kvp";
 export * from "./Resource";
 export * from "./utils/index";

package/index.js

@@ -2,6 +2,7 @@ export * from "./utils";
 export * from "./net/NetworkedMap";
 export * from "./decors/Events";
 export * from "./Convar";
+export * from "./Command";
 export * from "./Kvp";
 export * from "./Resource";
 export * from "./utils/index";

package/package.json

@@ -4,7 +4,7 @@
   "author": "Remco Troost <d0p3t>",
   "license": "MIT",
   "type": "module",
-  "version": "0.0.60",
+  "version": "0.0.62",
   "repository": {
     "type": "git",
     "url": "https://github.com/nativewrappers/nativewrappers.git"