@nativewrappers/common 0.0.143 → 0.0.145

package/Command.d.ts

@@ -1,5 +1,5 @@
 type Restricted = boolean | string | string[];
-interface ParameterTypes {
+export interface ParameterTypes {
     number: number;
     playerId: number;
     string: string;
@@ -19,6 +19,40 @@ type MappedParameters<T extends Parameter[]> = {
     raw: string;
 };
 type CommandHandler<T extends Parameter[]> = (args: MappedParameters<T>) => void | Promise<void>;
+type CommandContextObject<T> = {
+    source: number;
+    raw: string;
+    defaultValue?: T;
+};
+type CommandTypeParser<T> = (arg: string, context: CommandContextObject<T>) => T | undefined;
+/**
+ * Defines a parser for {@link Command} so that you can dynamically add new parsers,
+ * or overwrite existing parsers to your needs.
+ *
+ *
+ * You will need to declare a module to extend the parameter types, like so:
+ *  declare module "@nativewrappers/{client|common|server}" {
+ *   interface ParameterTypes {
+ *     playerId: MyFrameworkPlayer; // your custom player return type here
+ *   }
+ * }
+ *
+ * @param name - the name of the parser to register
+ * @param parser - the parser that will be ran for the specified type, the parser cannot be async, if validation
+ * fails you can throw an error, this error will be printed to the console. It should
+ * be noted that if there wasn't an argument for an index the parser will never get called.
+ * @example
+ * ```ts
+ * registerParameterType("number", (arg) => {
+ *   const num = parseInt(arg, 10);
+ *   if (Number.isNaN(num)) {
+ *     throw new TypeError(`could not parse argument into a valid number`);
+ *   }
+ *   return num;
+ * });
+ * ```
+ */
+export declare function registerParameterType<K extends keyof ParameterTypes>(name: K, parser: CommandTypeParser<ParameterTypes[K]>): void;
 /**
  * ```typescript
  * new Command(["do", "deleteobjects"], async ({source, radius}) => {

package/Command.js

@@ -3,7 +3,10 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 import { GlobalData } from "./GlobalData";
 const commands = [];
 $SERVER: {
-  on("playerJoining", () => emitNet("chat:addSuggestions", source, commands));
+  (() => {
+    $CLIENT: if (GlobalData.IS_CLIENT) return;
+    on("playerJoining", () => emitNet("chat:addSuggestions", source, commands));
+  })();
 }
 function registerCommand(name, commandHandler, restricted = true) {
   if (Array.isArray(name)) {
@@ -30,6 +33,55 @@ function registerCommand(name, commandHandler, restricted = true) {
   }
 }
 __name(registerCommand, "registerCommand");
+const commandTypeParserRegistry = /* @__PURE__ */ new Map();
+function registerParameterType(name, parser) {
+  commandTypeParserRegistry.set(name, parser);
+}
+__name(registerParameterType, "registerParameterType");
+registerParameterType("number", (arg) => {
+  const num = parseInt(arg, 10);
+  if (Number.isNaN(num)) {
+    throw new TypeError(`could not parse argument into a valid number`);
+  }
+  return num;
+});
+registerParameterType("string", (arg) => {
+  return arg;
+});
+(() => {
+  $CLIENT: if (GlobalData.IS_CLIENT) {
+    registerParameterType("playerId", (arg) => {
+      const isMe = arg === "me";
+      const target = isMe ? GetPlayerServerId(PlayerId()) : parseInt(arg, 10);
+      if (Number.isNaN(target)) {
+        throw new TypeError(`could not parse argument into a valid playerId`);
+      }
+      if (isMe) {
+        return target;
+      }
+      if (GetPlayerFromServerId(target) === -1) {
+        throw new Error(`player with server id $${target} didn't exist`);
+      }
+      return target;
+    });
+    return;
+  }
+  $SERVER: {
+    registerParameterType("playerId", (arg, { source: source2 }) => {
+      const target = arg === "me" ? source2 : parseInt(arg, 10);
+      if (Number.isNaN(target)) {
+        throw new TypeError(`could not parse argument into a valid playerId`);
+      }
+      if (!DoesPlayerExist(target)) {
+        throw new Error(`player at ${source2} didn't exist`);
+      }
+      return target;
+    });
+  }
+})();
+registerParameterType("longString", (arg, { raw }) => {
+  return raw.substring(raw.indexOf(arg));
+});
 class Command {
   /**
    * Registers a new executable command with optional parameter validation and permission restrictions.
@@ -88,39 +140,31 @@ class Command {
       raw
     };
     if (!this.params) return mapped;
+    const defaultContextObject = {
+      source: source2,
+      raw
+    };
     const result = this.params.every((param, index) => {
       const arg = args[index];
       let value = arg;
-      const hasDefaultValue = param.defaultValue !== void 0;
       const hasArg = typeof arg === "string";
-      if (!hasArg && hasDefaultValue) {
+      if (!hasArg) {
         value = param.defaultValue;
       } else {
-        switch (param.type) {
-          case "number":
-            if (hasDefaultValue && !hasArg) {
-              value = param.defaultValue;
-            } else {
-              value = +arg;
-            }
-            break;
-          case "string":
-            value = !Number(arg) ? arg : false;
-            break;
-          case "playerId":
-            $SERVER: {
-              value = arg === "me" ? source2 : +arg;
-              if (!value || !DoesPlayerExist(value.toString())) value = void 0;
-            }
-            $CLIENT: {
-              value = arg === "me" ? GetPlayerServerId(PlayerId()) : +arg;
-              if (!value || GetPlayerFromServerId(value) === -1) value = void 0;
-            }
-            break;
-          case "longString":
-            value = raw.substring(raw.indexOf(arg));
-            break;
+        const parser = commandTypeParserRegistry.get(param.type);
+        if (!parser) {
+          console.error(
+            `${param.type} didn't have a valid parser, did you forget to register it with 'registerParameterType'?`
+          );
+          return false;
+        }
+        try {
+          value = parser(arg, defaultContextObject);
+        } catch (e) {
+          globalThis.printError("command parsing", e);
+          return false;
         }
+        defaultContextObject.defaultValue = param.defaultValue;
       }
       if (value === void 0 && (!param.optional || param.optional && arg)) {
         return Citizen.trace(
@@ -150,5 +194,6 @@ ${err.message}`);
   }
 }
 export {
-  Command
+  Command,
+  registerParameterType
 };

package/decors/ConVar.d.ts

@@ -1,10 +1,14 @@
+/**
+ * The convar type that will be used for the specified decor
+ */
 export declare enum ConVarType {
     String = 0,
     Integer = 1,
     Float = 2,
     Boolean = 3
 }
-export type DeserializeFn = (data: unknown) => unknown;
+export type DeserializeFn<T extends ConVarType> = (data: InferType<T>) => any;
+type InferType<T extends ConVarType> = T extends ConVarType.String ? string : T extends ConVarType.Integer ? number : T extends ConVarType.Float ? number : T extends ConVarType.Boolean ? boolean : never;
 /**
  * Gets the specified `ConVar`s value, this will bind to the parameter of the current class
  * updating it whenever the ConVar value changes.
@@ -48,4 +52,5 @@ export type DeserializeFn = (data: unknown) => unknown;
  * }
  * ```
  */
-export declare function ConVar(name: string, convarType: ConVarType, deserialize?: DeserializeFn): (_initialValue: any, context: ClassFieldDecoratorContext, ..._args: any[]) => void;
+export declare function ConVar<T extends ConVarType>(name: string, convarType: T, deserialize?: DeserializeFn<T>): (_initialValue: any, context: ClassFieldDecoratorContext, ..._args: any[]) => void;
+export {};

package/decors/ConVar.js

@@ -21,7 +21,7 @@ const getConvarFunction = /* @__PURE__ */ __name((con_var_type) => {
     // needed so typescript wont complain about "unreachable code" for the error below
     default:
   }
-  throw new Error("Got invalid ConVarType");
+  throw new Error(`Got conVarType: ${con_var_type} but it was not a valid ConVar type, please refer to "ConVarType"`);
 }, "getConvarFunction");
 function ConVar(name, convarType, deserialize) {
   return /* @__PURE__ */ __name(function actualDecorator(_initialValue, context, ..._args) {

package/decors/Proto.d.ts

@@ -0,0 +1,26 @@
+export type MessageTypeDecoder<T> = {
+    decode: (input: Uint8Array) => T;
+    name: string;
+};
+export type MessageTypeEncoder<T> = {
+    encode: (message: T) => any;
+    name: string;
+};
+type ProtoCallback<Message> = (message: Message) => Promise<void>;
+type NetProtoCallback<Message> = (source: number, message: Message) => Promise<void>;
+/**
+ * PMA uses ts-proto to define our types, you can see that here: https://github.com/stephenh/ts-proto
+ * You will have to modify the generator to add `name` or just use {@param eventName}
+ *
+ * We use this:
+ * content = content.replace(/export const (\w+)[^=]*= \{/g, 'export const $1 = {\n  name: "$1" as const,');
+ *
+ * This makes it very nice to handle events since we only have to give it the Protobuf Object
+ *
+ */
+export declare function OnProto<T>(messageType: MessageTypeDecoder<T>, eventName?: string): (originalMethod: ProtoCallback<T>, context: ClassMethodDecoratorContext) => void;
+/**
+ * This makes it very nice to handle events since we only have to give it the Protobuf Object
+ */
+export declare function OnProtoNet<T>(messageType: MessageTypeDecoder<T>, eventName?: string): (originalMethod: NetProtoCallback<T>, context: ClassMethodDecoratorContext) => void;
+export {};

package/decors/Proto.js

@@ -0,0 +1,50 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Net } from "../net/Net";
+function parseSource(source) {
+  const id = source.replace(/^(internal-)?net:/, "");
+  return parseInt(id, 10);
+}
+__name(parseSource, "parseSource");
+function OnProto(messageType, eventName) {
+  const event = eventName ?? `pb:${messageType.name}`;
+  return /* @__PURE__ */ __name(function actualDecorator(originalMethod, context) {
+    if (context.private) {
+      throw new Error("OnProto does not work on private methods");
+    }
+    context.addInitializer(function() {
+      Net.onRaw(event, async (data) => {
+        try {
+          const message = messageType.decode(data);
+          return await originalMethod.call(this, message);
+        } catch (e) {
+          globalThis.printError?.("proto event", e);
+        }
+      });
+    });
+  }, "actualDecorator");
+}
+__name(OnProto, "OnProto");
+function OnProtoNet(messageType, eventName) {
+  const event = eventName ?? `pb:${messageType.name}`;
+  return /* @__PURE__ */ __name(function actualDecorator(originalMethod, context) {
+    if (context.private) {
+      throw new Error("OnProto does not work on private methods");
+    }
+    context.addInitializer(function() {
+      Net.onRawNet(event, async (data, source) => {
+        try {
+          const message = messageType.decode(data);
+          return await originalMethod.call(this, parseSource(source), message);
+        } catch (e) {
+          globalThis.printError?.("proto event", e);
+        }
+      });
+    });
+  }, "actualDecorator");
+}
+__name(OnProtoNet, "OnProtoNet");
+export {
+  OnProto,
+  OnProtoNet
+};

package/index.d.ts

@@ -19,11 +19,13 @@ export * from "./utils/enumValues";
 export * from "./utils/getStringFromUInt8Array";
 export * from "./utils/getUInt32FromUint8Array";
 export * from "./utils/randomInt";
+export * from "./net/Net";
 export * from "./net/NetworkedMap";
 export * from "./decors/ConVar";
 export * from "./decors/Events";
 export * from "./decors/Exports";
 export * from "./decors/Permissions";
+export * from "./decors/Proto";
 export * from "./decors/Resources";
 export * from "./decors/Ticks";
 export * from "./collections/CircularBuffer";

package/index.js

@@ -19,11 +19,13 @@ export * from "./utils/enumValues";
 export * from "./utils/getStringFromUInt8Array";
 export * from "./utils/getUInt32FromUint8Array";
 export * from "./utils/randomInt";
+export * from "./net/Net";
 export * from "./net/NetworkedMap";
 export * from "./decors/ConVar";
 export * from "./decors/Events";
 export * from "./decors/Exports";
 export * from "./decors/Permissions";
+export * from "./decors/Proto";
 export * from "./decors/Resources";
 export * from "./decors/Ticks";
 export * from "./collections/CircularBuffer";

package/net/Net.d.ts

@@ -0,0 +1,21 @@
+import type { MessageTypeEncoder } from "../decors/Proto";
+type EventCallback = (...args: any[]) => void;
+type RawEventCallback = (data: Uint8Array, source: `internal-net:${number}` | `net:${number}`) => void;
+export declare class Net {
+    static emit(eventName: string, ...args: any[]): void;
+    static on(eventName: string, cb: EventCallback): void;
+    static onNet(eventName: string, cb: EventCallback): void;
+    static onRaw(eventName: string, cb: RawEventCallback): void;
+    static onRawNet(eventName: string, cb: RawEventCallback): void;
+}
+export declare class NetServer extends Net {
+    static emitNet(eventName: string, source: number, ...args: any[]): void;
+    static emitProto<T>(source: number, message: MessageTypeEncoder<T>): void;
+    static emitRawNet(eventName: string, source: number, data: Uint8Array): void;
+}
+export declare class NetClient extends Net {
+    static emitNet(eventName: string, source: number, ...args: any[]): void;
+    static emitProto<T>(message: MessageTypeEncoder<T>): void;
+    static emitRawNet(eventName: string, data: Uint8Array): void;
+}
+export {};

package/net/Net.js

@@ -0,0 +1,59 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class Net {
+  static {
+    __name(this, "Net");
+  }
+  static emit(eventName, ...args) {
+    emit(eventName, ...args);
+  }
+  static on(eventName, cb) {
+    on(eventName, cb);
+  }
+  static onNet(eventName, cb) {
+    onNet(eventName, cb);
+  }
+  static onRaw(eventName, cb) {
+    RegisterResourceAsEventHandler(eventName);
+    addRawEventListener(eventName, cb);
+  }
+  static onRawNet(eventName, cb) {
+    RegisterNetEvent(eventName);
+    Net.onRaw(eventName, cb);
+  }
+}
+class NetServer extends Net {
+  static {
+    __name(this, "NetServer");
+  }
+  static emitNet(eventName, source, ...args) {
+    emitNet(eventName, source, ...args);
+  }
+  static emitProto(source, message) {
+    const encoded = message.encode(message);
+    NetServer.emitRawNet(message.name, source, encoded);
+  }
+  static emitRawNet(eventName, source, data) {
+    TriggerClientEventInternal(eventName, source, data, data.byteLength);
+  }
+}
+class NetClient extends Net {
+  static {
+    __name(this, "NetClient");
+  }
+  static emitNet(eventName, source, ...args) {
+    emitNet(eventName, source, ...args);
+  }
+  static emitProto(message) {
+    const encoded = message.encode(message);
+    NetClient.emitRawNet(message.name, encoded);
+  }
+  static emitRawNet(eventName, data) {
+    TriggerServerEventInternal(eventName, data, data.byteLength);
+  }
+}
+export {
+  Net,
+  NetClient,
+  NetServer
+};

package/net/NetworkedMap.d.ts

@@ -1,10 +1,20 @@
+declare enum MapChangeType {
+    SubValueChanged = 0,
+    Add = 1,
+    Remove = 2,
+    Reset = 3,
+    Init = 4,
+    Resync = 5
+}
+type MapChanges<K, V> = [MapChangeType, K?, V?] | [MapChangeType.SubValueChanged, K, string, any];
 type ChangeListener<V> = (value: V | undefined) => void;
 /**
  * not ready to be used just thoughts right now
  */
 export declare class NetworkedMap<K, V> extends Map<K, V> {
     #private;
-    constructor(syncName: string, initialValue?: [K, V][]);
+    constructor(syncName: string);
+    initialize(initialValue: [K, V][]): void;
     get SyncName(): string;
     private onPlayerDropped;
     resync(source: number): void;
@@ -12,7 +22,7 @@ export declare class NetworkedMap<K, V> extends Map<K, V> {
     removeSubscriber(sub: number): boolean;
     hasSubscriber(sub: number): boolean;
     subscriberCount(): number;
-    private handleSync;
+    protected handleSync(data: MapChanges<K, V>[]): void;
     listenForChange(key: K, fn: ChangeListener<V | undefined>): void;
     set(key: K, value: V): this;
     clear(): void;

package/net/NetworkedMap.js

@@ -1,6 +1,7 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 import { GlobalData } from "../GlobalData";
+import { Net } from "../net/Net";
 class NetworkedMapEventManager {
   static {
     __name(this, "NetworkedMapEventManager");
@@ -17,8 +18,8 @@ class NetworkedMapEventManager {
       return;
     }
     $CLIENT: {
-      RegisterResourceAsEventHandler(`${GlobalData.CurrentResource}:syncChanges`);
-      addRawEventListener(`${GlobalData.CurrentResource}:syncChanges`, (msgpack_data) => {
+      if (GlobalState.IS_SERVER) return;
+      Net.onRaw(`${GlobalData.CurrentResource}:syncChanges`, (msgpack_data) => {
         const data = msgpack_unpack(msgpack_data);
         const syncName = data[0];
         const syncData = data[1];
@@ -46,8 +47,8 @@ class NetworkedMap extends Map {
   #queuedChanges = [];
   #changeListeners = /* @__PURE__ */ new Map();
   #subscribers = /* @__PURE__ */ new Set();
-  constructor(syncName, initialValue) {
-    super(initialValue);
+  constructor(syncName) {
+    super();
     this.#syncName = syncName;
     GlobalData.NetworkedTicks.push(this);
     netManager.addNetworkedMap(this);
@@ -61,6 +62,11 @@ class NetworkedMap extends Map {
       }
     }
   }
+  initialize(initialValue) {
+    for (const [k, v] of initialValue) {
+      this.set(k, v);
+    }
+  }
   get SyncName() {
     return this.#syncName;
   }

package/package.json

@@ -8,7 +8,7 @@
   ],
   "license": "MIT",
   "type": "module",
-  "version": "0.0.143",
+  "version": "0.0.145",
   "repository": {
     "type": "git",
     "url": "https://github.com/nativewrappers/nativewrappers.git"