@nativewrappers/server 0.0.78 → 0.0.79

package/index.d.ts

@@ -1,7 +1,6 @@
 export * from "./utils";
-export * from "./Events";
 export * from "./Game";
-export { Convar, Kvp, Resource, Command } from "./common/index";
+export * from "./common/index";
 export * from "./enum/index";
 export * from "./utils/index";
 export * from "./entities/index";

package/index.js

@@ -584,6 +584,21 @@ var Vector4 = class _Vector4 extends Vector {
   }
 };
 
+// src/common/utils/PointF.ts
+var PointF = class _PointF {
+  constructor(x, y, z) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+  }
+  static {
+    __name(this, "PointF");
+  }
+  static empty() {
+    return new _PointF(0, 0, 0);
+  }
+};
+
 // src/common/utils/Maths.ts
 var Maths = class {
   static {
@@ -836,22 +851,6 @@ var BaseEntity = class _BaseEntity {
   }
 };
 
-// src/server/entities/Entity.ts
-var Entity2 = class _Entity extends BaseEntity {
-  static {
-    __name(this, "Entity");
-  }
-  constructor(handle) {
-    super(handle);
-  }
-  static fromNetworkId(netId) {
-    return new _Entity(NetworkGetEntityFromNetworkId(netId));
-  }
-  static fromHandle(handle) {
-    return new _Entity(handle);
-  }
-};
-
 // src/server/entities/Vehicle.ts
 var Vehicle = class _Vehicle extends BaseEntity {
   static {
@@ -1241,119 +1240,6 @@ var Player2 = class _Player {
   }
 };
 
-// src/server/entities/Prop.ts
-var Prop = class _Prop extends BaseEntity {
-  static {
-    __name(this, "Prop");
-  }
-  type = 1 /* Prop */;
-  constructor(handle) {
-    super(handle);
-  }
-  /**
-   * Get an interable list of props currently on the server
-   * @returns Iterable list of Props.
-   */
-  static *AllProps() {
-    for (const prop of GetAllObjects()) {
-      yield new _Prop(prop);
-    }
-  }
-  static fromNetworkId(networkId) {
-    const ent = NetworkGetEntityFromNetworkId(networkId);
-    if (ent === 0) return null;
-    return new _Prop(ent);
-  }
-  static fromStateBagName(stateBagName) {
-    const ent = GetEntityFromStateBagName(stateBagName);
-    if (ent === 0) return null;
-    return new _Prop(ent);
-  }
-  static fromHandle(handle) {
-    return new _Prop(handle);
-  }
-};
-
-// src/server/Events.ts
-var getClassFromArguments = /* @__PURE__ */ __name((...args) => {
-  const newArgs = [];
-  for (const arg of args) {
-    if (!arg.type) {
-      newArgs.push(arg);
-      continue;
-    }
-    switch (arg.type) {
-      case 5 /* Vector2 */: {
-        newArgs.push(Vector2.fromObject(arg));
-        continue;
-      }
-      case 6 /* Vector3 */: {
-        newArgs.push(Vector3.fromObject(arg));
-        continue;
-      }
-      case 7 /* Vector4 */: {
-        newArgs.push(Vector4.fromObject(arg));
-        continue;
-      }
-      case 0 /* Ped */: {
-        newArgs.push(Ped.fromNetworkId(arg.handle));
-        continue;
-      }
-      case 4 /* Player */: {
-        newArgs.push(new Player2(arg.source));
-        continue;
-      }
-      case 1 /* Prop */: {
-        newArgs.push(Prop.fromNetworkId(arg.handle));
-        continue;
-      }
-      case 2 /* Vehicle */: {
-        newArgs.push(Vehicle.fromNetworkId(arg.netId));
-        continue;
-      }
-      case 3 /* Entity */: {
-        newArgs.push(Entity2.fromNetworkId(arg.netId));
-        continue;
-      }
-      default: {
-        newArgs.push(arg);
-      }
-    }
-  }
-  return newArgs;
-}, "getClassFromArguments");
-var Events = class {
-  static {
-    __name(this, "Events");
-  }
-  static cancel() {
-    CancelEvent();
-  }
-  static wasCanceled() {
-    return WasEventCanceled();
-  }
-  static get InvokingResource() {
-    return GetInvokingResource();
-  }
-  /**
-   * An onNet wrapper that properly converts the type into the correct type
-   */
-  static onNet = /* @__PURE__ */ __name((eventName, event) => {
-    onNet(eventName, (...args) => {
-      const ply = new Player2(source);
-      event(ply, ...getClassFromArguments(...args));
-    });
-  }, "onNet");
-  /**
-   * An on wrapper that properly converts the classes
-   */
-  static on = /* @__PURE__ */ __name((eventName, event) => {
-    on(eventName, (...args) => {
-      event(...getClassFromArguments(...args));
-    });
-  }, "on");
-};
-
 // src/server/Game.ts
 var Game = class {
   static {
@@ -1450,6 +1336,340 @@ var NetworkedMapEventManager = class {
   }
 };
 var netManager = new NetworkedMapEventManager();
+var NetworkedMap = class extends Map {
+  static {
+    __name(this, "NetworkedMap");
+  }
+  #syncName;
+  #queuedChanges = [];
+  #changeListeners = /* @__PURE__ */ new Map();
+  #subscribers = /* @__PURE__ */ new Set();
+  constructor(syncName, initialValue) {
+    super(initialValue);
+    this.#syncName = syncName;
+    GlobalData.NetworkedTicks.push(this);
+    netManager.addNetworkedMap(this);
+    $SERVER: {
+      if (!GlobalData.NetworkTick && GlobalData.IS_SERVER) {
+        GlobalData.NetworkTick = setTick(() => {
+          for (const networkedThis of GlobalData.NetworkedTicks) {
+            networkedThis.networkTick();
+          }
+        });
+      }
+    }
+  }
+  get SyncName() {
+    return this.#syncName;
+  }
+  // handles removing the player from the map whenever they're dropped
+  onPlayerDropped() {
+    this.removeSubscriber(source);
+  }
+  /*
+   * Resyncs the entire map to the client, useful for if there's a mismatch in the clients map (when multiple players change things, in cases like inventories)
+   *
+   * NOTE: This doesn't check that the player is already subscribed to the map, you should do your own due-diligence to only call this for players already subscribed
+   */
+  resync(source2) {
+    const packed_data = msgpack_pack([this.#syncName, [[4 /* Init */, this.size === 0 ? [] : Array.from(this)]]]);
+    TriggerClientEventInternal(
+      `${GlobalData.CurrentResource}:syncChanges`,
+      source2,
+      packed_data,
+      packed_data.length
+    );
+  }
+  /*
+   * Adds a new subscriber to the map
+   */
+  addSubscriber(source2) {
+    this.#subscribers.add(source2);
+    this.resync(source2);
+  }
+  removeSubscriber(sub) {
+    return this.#subscribers.delete(sub);
+  }
+  hasSubscriber(sub) {
+    return this.#subscribers.has(sub);
+  }
+  subscriberCount() {
+    return this.#subscribers.size;
+  }
+  handleSync(data) {
+    for (const [change_type, key, value, possibly_undefined_subvalue] of data) {
+      switch (change_type) {
+        case 1 /* Add */: {
+          this.set(key, value);
+          continue;
+        }
+        case 2 /* Remove */: {
+          super.delete(key);
+          continue;
+        }
+        case 3 /* Reset */: {
+          super.clear();
+          continue;
+        }
+        case 4 /* Init */: {
+          super.clear();
+          const key_value = key;
+          for (const [k, v] of key_value) {
+            this.set(k, v);
+          }
+          continue;
+        }
+        case 0 /* SubValueChanged */: {
+          const data2 = this.get(key);
+          data2[value] = possibly_undefined_subvalue;
+          continue;
+        }
+      }
+    }
+  }
+  /*
+   * Listens for the change on the specified key, it will get the resulting
+   * value on the change
+   */
+  listenForChange(key, fn) {
+    const listener = this.#changeListeners.get(key);
+    listener ? listener.push(fn) : this.#changeListeners.set(key, [fn]);
+  }
+  #triggerEventForSubscribers(data) {
+    const packed_data = msgpack_pack([this.#syncName, data]);
+    for (const sub of this.#subscribers) {
+      TriggerClientEventInternal(
+        `${GlobalData.CurrentResource}:syncChanges`,
+        sub,
+        packed_data,
+        packed_data.length
+      );
+    }
+  }
+  #pushChangeForListener(key, value) {
+    const listener = this.#changeListeners.get(key);
+    if (!listener) return;
+    for (const ln of listener) {
+      ln(value);
+    }
+  }
+  set(key, value) {
+    let v = value;
+    if (value instanceof Object) {
+      const curMap = this;
+      const objectChangeHandler = {
+        get(target, prop, reciever) {
+          return Reflect.get(target, prop, reciever);
+        },
+        set(target, p, newValue, receiver) {
+          const success = Reflect.set(target, p, newValue, receiver);
+          if (success) {
+            curMap.#pushChangeForListener(key, target);
+            $SERVER: {
+              curMap.#queuedChanges.push([0 /* SubValueChanged */, key, p, newValue]);
+            }
+          }
+          return success;
+        }
+      };
+      v = new Proxy(v, objectChangeHandler);
+    }
+    super.set(key, v);
+    this.#pushChangeForListener(key, v);
+    $SERVER: {
+      this.#queuedChanges.push([1 /* Add */, key, v]);
+    }
+    return this;
+  }
+  /*
+   * Resets the map to its default state
+   */
+  clear() {
+    this.#queuedChanges = [];
+    this.#queuedChanges.push([3 /* Reset */]);
+    super.clear();
+  }
+  delete(key) {
+    this.#queuedChanges.push([2 /* Remove */, key]);
+    return super.delete(key);
+  }
+  networkTick() {
+    if (this.#queuedChanges.length !== 0) {
+      this.#triggerEventForSubscribers(this.#queuedChanges);
+      this.#queuedChanges = [];
+    }
+  }
+  [Symbol.dispose]() {
+    this.#subscribers.clear();
+    this.#changeListeners.clear();
+    this.#queuedChanges = [];
+    netManager.removeNetworkedMap(this.#syncName);
+    GlobalData.NetworkedTicks.filter((v) => v !== this);
+  }
+  /**
+   * Unregisters from the tick handler and removes the event listener
+   */
+  dispose() {
+    this[Symbol.dispose]();
+  }
+  get [Symbol.toStringTag]() {
+    return "NetworkedMap";
+  }
+};
+
+// src/common/decors/Events.ts
+var ConVarType = /* @__PURE__ */ ((ConVarType2) => {
+  ConVarType2[ConVarType2["String"] = 0] = "String";
+  ConVarType2[ConVarType2["Integer"] = 1] = "Integer";
+  ConVarType2[ConVarType2["Float"] = 2] = "Float";
+  ConVarType2[ConVarType2["Boolean"] = 3] = "Boolean";
+  return ConVarType2;
+})(ConVarType || {});
+var DisablePrettyPrint = /* @__PURE__ */ __name(() => GlobalData.EnablePrettyPrint = false, "DisablePrettyPrint");
+function Exports(exportName) {
+  return /* @__PURE__ */ __name(function actualDecorator(originalMethod, context) {
+    if (context.private) {
+      throw new Error("Exports does not work on private methods, please mark the method as public");
+    }
+    context.addInitializer(function() {
+      exports(exportName, (...args) => {
+        return originalMethod.call(this, ...args);
+      });
+    });
+  }, "actualDecorator");
+}
+__name(Exports, "Exports");
+function Event(eventName) {
+  return /* @__PURE__ */ __name(function actualDecorator(originalMethod, context) {
+    if (context.private) {
+      throw new Error("Event does not work on private methods, please mark the method as public");
+    }
+    context.addInitializer(function() {
+      on(eventName, (...args) => {
+        try {
+          return originalMethod.call(this, ...args);
+        } catch (e) {
+          REMOVE_EVENT_LOG: {
+            if (!GlobalData.EnablePrettyPrint) return;
+            console.error("------- EVENT ERROR --------");
+            console.error(`Call to ${eventName} errored`);
+            console.error(`Data: ${JSON.stringify(args)}`);
+            console.error(`Error: ${e}`);
+            console.error("------- END EVENT ERROR --------");
+          }
+        }
+      });
+    });
+  }, "actualDecorator");
+}
+__name(Event, "Event");
+function NetEvent(eventName, remoteOnly = true) {
+  return /* @__PURE__ */ __name(function actualDecorator(originalMethod, context) {
+    if (context.private) {
+      throw new Error("NetEvent does not work on private methods, please mark the method as public");
+    }
+    context.addInitializer(function() {
+      onNet(eventName, (...args) => {
+        const src = source;
+        try {
+          return originalMethod.call(this, ...args);
+        } catch (e) {
+          REMOVE_NET_EVENT_LOG: {
+            if (!GlobalData.EnablePrettyPrint) return;
+            console.error("------- NET EVENT ERROR --------");
+            console.error(`Call to ${eventName} errored`);
+            console.error(`Caller: ${src}`);
+            console.error(`Data: ${JSON.stringify(args)}`);
+            console.error(`Error: ${e}`);
+            console.error("------- END NET EVENT ERROR --------");
+          }
+        }
+      });
+    });
+  }, "actualDecorator");
+}
+__name(NetEvent, "NetEvent");
+function NuiEvent(eventName) {
+  return /* @__PURE__ */ __name(function actualDecorator(originalMethod, context) {
+    if (context.private) {
+      throw new Error("NuiEvent does not work on private methods, please mark the method as public");
+    }
+    context.addInitializer(function() {
+      RegisterNuiCallback(eventName, (...args) => {
+        return originalMethod.call(this, ...args);
+      });
+    });
+  }, "actualDecorator");
+}
+__name(NuiEvent, "NuiEvent");
+var get_convar_fn = /* @__PURE__ */ __name((con_var_type) => {
+  switch (con_var_type) {
+    case 0 /* String */:
+      return GetConvar;
+    case 1 /* Integer */:
+      return GetConvarInt;
+    case 2 /* Float */:
+      return GetConvarFloat;
+    case 3 /* Boolean */:
+      return GetConvarBool;
+    // needed so typescript wont complain about "unreachable code" for the error below
+    default:
+  }
+  throw new Error("Got invalid ConVarType");
+}, "get_convar_fn");
+function ConVar(name, is_floating_point, deserialize) {
+  return /* @__PURE__ */ __name(function actualDecorator(_initialValue, context, ..._args) {
+    if (context.private) {
+      throw new Error("ConVar does not work on private types, please mark the field as public");
+    }
+    context.addInitializer(function() {
+      const t = this;
+      const default_value = Reflect.get(t, context.name);
+      const default_type = typeof default_value;
+      let con_var_type = null;
+      if (default_type === "number") {
+        if (is_floating_point || !Number.isInteger(default_value)) {
+          con_var_type = 2 /* Float */;
+        } else {
+          con_var_type = 1 /* Integer */;
+        }
+      } else if (default_type === "boolean") {
+        con_var_type = 3 /* Boolean */;
+      } else if (default_value === "string") {
+        con_var_type = 0 /* String */;
+      }
+      if (!deserialize && con_var_type === null) {
+        throw new Error("You should provide a deserialize function if you want to convert this to an object type");
+      }
+      if (con_var_type === null) {
+        con_var_type = 0 /* String */;
+      }
+      const con_var_fn = get_convar_fn(con_var_type);
+      const get_convar_value = /* @__PURE__ */ __name(() => {
+        const data = con_var_fn(name, default_value);
+        return deserialize ? deserialize(data) : data;
+      }, "get_convar_value");
+      Reflect.set(t, context.name, get_convar_value());
+      AddConvarChangeListener(name, () => {
+        Reflect.set(t, context.name, get_convar_value());
+      });
+    });
+  }, "actualDecorator");
+}
+__name(ConVar, "ConVar");
+function SetTick() {
+  return /* @__PURE__ */ __name(function actualDecorator(originalMethod, context) {
+    if (context.private) {
+      throw new Error("SetTick does not work on private types, please mark the field as public");
+    }
+    context.addInitializer(function() {
+      setTick(async () => {
+        await originalMethod.call(this);
+      });
+    });
+  }, "actualDecorator");
+}
+__name(SetTick, "SetTick");
 
 // src/common/Convar.ts
 var Convar = class {
@@ -1816,23 +2036,81 @@ var OrphanMode = /* @__PURE__ */ ((OrphanMode2) => {
   OrphanMode2[OrphanMode2["KeepEntity"] = 2] = "KeepEntity";
   return OrphanMode2;
 })(OrphanMode || {});
+
+// src/server/entities/Entity.ts
+var Entity2 = class _Entity extends BaseEntity {
+  static {
+    __name(this, "Entity");
+  }
+  constructor(handle) {
+    super(handle);
+  }
+  static fromNetworkId(netId) {
+    return new _Entity(NetworkGetEntityFromNetworkId(netId));
+  }
+  static fromHandle(handle) {
+    return new _Entity(handle);
+  }
+};
+
+// src/server/entities/Prop.ts
+var Prop = class _Prop extends BaseEntity {
+  static {
+    __name(this, "Prop");
+  }
+  type = 1 /* Prop */;
+  constructor(handle) {
+    super(handle);
+  }
+  /**
+   * Get an interable list of props currently on the server
+   * @returns Iterable list of Props.
+   */
+  static *AllProps() {
+    for (const prop of GetAllObjects()) {
+      yield new _Prop(prop);
+    }
+  }
+  static fromNetworkId(networkId) {
+    const ent = NetworkGetEntityFromNetworkId(networkId);
+    if (ent === 0) return null;
+    return new _Prop(ent);
+  }
+  static fromStateBagName(stateBagName) {
+    const ent = GetEntityFromStateBagName(stateBagName);
+    if (ent === 0) return null;
+    return new _Prop(ent);
+  }
+  static fromHandle(handle) {
+    return new _Prop(handle);
+  }
+};
 export {
   Color,
   Command,
+  ConVar,
+  ConVarType,
   Convar,
   Delay,
+  DisablePrettyPrint,
   Entity2 as Entity,
-  Events,
+  Event,
+  Exports,
   Game,
   Kvp,
   Maths,
+  NetEvent,
+  NetworkedMap,
+  NuiEvent,
   OrphanMode,
   Ped,
   Player2 as Player,
+  PointF,
   PopulationType,
   Prop,
   Quaternion,
   Resource,
+  SetTick,
   Vector2,
   Vector3,
   Vector4,

package/package.json

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

package/Events.d.ts

@@ -1,16 +0,0 @@
-import { Player } from "./entities/Player";
-export type NetEvent = (player: Player, ...args: any[]) => void;
-export type LocalEvent = (...args: any[]) => void;
-export declare class Events {
-    static cancel(): void;
-    static wasCanceled(): boolean;
-    static get InvokingResource(): string;
-    /**
-     * An onNet wrapper that properly converts the type into the correct type
-     */
-    static onNet: (eventName: string, event: NetEvent) => void;
-    /**
-     * An on wrapper that properly converts the classes
-     */
-    static on: (eventName: string, event: LocalEvent) => void;
-}