@nativewrappers/common 0.0.125 → 0.0.127

package/common-game/common/decors/Events.js

@@ -0,0 +1,163 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { GlobalData } from "../GlobalData";
+const DisablePrettyPrint = /* @__PURE__ */ __name(() => GlobalData.EnablePrettyPrint = false, "DisablePrettyPrint");
+const AsyncFunction = (async () => {
+}).constructor;
+var Binding = /* @__PURE__ */ ((Binding2) => {
+  Binding2[Binding2["None"] = 0] = "None";
+  Binding2[Binding2["Local"] = 1] = "Local";
+  Binding2[Binding2["Remote"] = 2] = "Remote";
+  Binding2[Binding2["All"] = 3] = "All";
+  return Binding2;
+})(Binding || {});
+function CfxEvent(eventName, binding = 1 /* Local */) {
+  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() {
+      const fn = (binding & 2 /* Remote */) !== 0 ? onNet : on;
+      const _t = this;
+      fn(eventName, async (...args) => {
+        const src = source;
+        if (_t.__permissionMap && binding & 2 /* Remote */) {
+          const permissions = _t.__permissionMap.get(context.name);
+          if (permissions) {
+            let hasPermission = false;
+            for (const perm of permissions) {
+              if (IsPlayerAceAllowed(src, perm)) {
+                hasPermission = true;
+                break;
+              }
+            }
+            if (!hasPermission) {
+              emit("@nativewrappers:no_permission", { eventName, method: context.name });
+              return;
+            }
+          }
+        }
+        try {
+          return await 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(CfxEvent, "CfxEvent");
+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, async (...args) => {
+        try {
+          return await 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() {
+      const _t = this;
+      onNet(eventName, async (...args) => {
+        const src = source;
+        if (_t.__permissionMap) {
+          const permissions = _t.__permissionMap.get(context.name);
+          if (permissions) {
+            let hasPermission = false;
+            for (const perm of permissions) {
+              if (IsPlayerAceAllowed(src, perm)) {
+                hasPermission = true;
+                break;
+              }
+            }
+            if (!hasPermission) {
+              emit("@nativewrappers:no_permission", { eventName, method: context.name });
+              return;
+            }
+          }
+        }
+        try {
+          $CLIENT: {
+            if (GlobalData.IS_CLIENT && remoteOnly && source !== 65535) {
+              return;
+            }
+          }
+          return await 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, dontErrorWhenCbIsntInvoked = false) {
+  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, async (data, cb) => {
+        let wasInvoked = false;
+        const cbWrapper = /* @__PURE__ */ __name((args) => {
+          wasInvoked = true;
+          cb(args);
+        }, "cbWrapper");
+        const retData = await originalMethod.call(this, data, cbWrapper);
+        if (!wasInvoked && !retData) {
+          if (dontErrorWhenCbIsntInvoked) return;
+          throw new Error(
+            `Error in NuiEvent ${eventName} '@NuiEvent' expects you to return data in your callback, or to return from the function call`
+          );
+        }
+        if (!wasInvoked) {
+          cb(retData);
+        }
+      });
+    });
+  }, "actualDecorator");
+}
+__name(NuiEvent, "NuiEvent");
+export {
+  Binding,
+  CfxEvent,
+  DisablePrettyPrint,
+  Event,
+  NetEvent,
+  NuiEvent
+};

package/common-game/common/decors/Exports.d.ts

@@ -0,0 +1 @@
+export declare function Exports(exportName: string): (originalMethod: any, context: ClassMethodDecoratorContext) => void;

package/common-game/common/decors/Exports.js

@@ -0,0 +1,53 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { GlobalData } from "../GlobalData";
+const AsyncFunction = (async () => {
+}).constructor;
+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() {
+      let exportCb;
+      if (originalMethod instanceof AsyncFunction) {
+        exportCb = /* @__PURE__ */ __name(async (...args) => {
+          try {
+            return await originalMethod.call(this, ...args);
+          } catch (err) {
+            REMOVE_EVENT_LOG: {
+              if (!GlobalData.EnablePrettyPrint) return;
+              console.error("------- EXPORT ERROR --------");
+              console.error(`Call to ${exportName} errored`);
+              console.error(`Data: ${JSON.stringify(args)}`);
+              console.error(`Error: ${err}`);
+              console.error("------- END EXPORT ERROR --------");
+            }
+            throw err;
+          }
+        }, "exportCb");
+      } else {
+        exportCb = /* @__PURE__ */ __name((...args) => {
+          try {
+            return originalMethod.call(this, ...args);
+          } catch (err) {
+            REMOVE_EVENT_LOG: {
+              if (!GlobalData.EnablePrettyPrint) return;
+              console.error("------- EXPORT ERROR --------");
+              console.error(`Call to ${exportName} errored`);
+              console.error(`Data: ${JSON.stringify(args)}`);
+              console.error(`Error: ${err}`);
+              console.error("------- END EXPORT ERROR --------");
+            }
+            throw err;
+          }
+        }, "exportCb");
+      }
+      exports(exportName, exportCb);
+    });
+  }, "actualDecorator");
+}
+__name(Exports, "Exports");
+export {
+  Exports
+};

package/common-game/common/decors/Permissions.d.ts

@@ -0,0 +1,3 @@
+export declare function RestrictToGroupAce(groupAceName: string): (originalMethod: any, context: ClassMethodDecoratorContext) => void;
+export declare function RestrictToJobAce(jobAce: string): (originalMethod: any, context: ClassMethodDecoratorContext) => void;
+export declare function RestrictToAce(aceName: string): (originalMethod: any, context: ClassMethodDecoratorContext) => void;

package/common-game/common/decors/Permissions.js

@@ -0,0 +1,49 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { GlobalData } from "../GlobalData";
+const addAcePermission = /* @__PURE__ */ __name((aceName, context) => {
+  context.addInitializer(function() {
+    const _t = this;
+    _t.__permissionMap = _t.__permissionMap ?? /* @__PURE__ */ new Map();
+    const ace_list = _t.__permissionMap.get(context.name);
+    if (ace_list) {
+      ace_list.add(aceName);
+    } else {
+      _t.__permissionMap.set(context.name, /* @__PURE__ */ new Set([aceName]));
+    }
+  });
+}, "addAcePermission");
+function RestrictToGroupAce(groupAceName) {
+  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");
+    }
+    const groupAce = `group.${groupAceName}`;
+    addAcePermission(groupAce, context);
+  }, "actualDecorator");
+}
+__name(RestrictToGroupAce, "RestrictToGroupAce");
+function RestrictToJobAce(jobAce) {
+  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");
+    }
+    const groupAce = `job.${jobAce}`;
+    addAcePermission(groupAce, context);
+  }, "actualDecorator");
+}
+__name(RestrictToJobAce, "RestrictToJobAce");
+function RestrictToAce(aceName) {
+  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");
+    }
+    addAcePermission(aceName, context);
+  }, "actualDecorator");
+}
+__name(RestrictToAce, "RestrictToAce");
+export {
+  RestrictToAce,
+  RestrictToGroupAce,
+  RestrictToJobAce
+};

package/common-game/common/decors/Resources.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Called whenever the specified resource is started, this will be called once on once on resource start if the resource is started.
+ */
+export declare function OnResourceStart(resource?: string): (originalMethod: any, context: ClassMethodDecoratorContext) => void;
+/**
+ * Called whenever the specified resource is stopped.
+ */
+export declare function OnResourceStop(resource?: string): (originalMethod: any, context: ClassMethodDecoratorContext) => void;

package/common-game/common/decors/Resources.js

@@ -0,0 +1,94 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Event } from "./Events";
+class ResourceWrapper {
+  static {
+    __name(this, "ResourceWrapper");
+  }
+  #on_resource_start = /* @__PURE__ */ new Map();
+  #on_resource_stop = /* @__PURE__ */ new Map();
+  #add_or_init(resource_fn_map, resource_name, fn) {
+    const fn_array = resource_fn_map.get(resource_name);
+    if (fn_array) {
+      fn_array.push(fn);
+    } else {
+      resource_fn_map.set(resource_name, [fn]);
+    }
+  }
+  /**
+   * Adds a function to get called whenever a resource is started
+   * @param resource_name The resource name to add to the start listener.
+   * @param fn The function to call
+   */
+  add_to_resource_start(resource_name, fn) {
+    this.#add_or_init(this.#on_resource_start, resource_name, fn);
+  }
+  /**
+   * Adds a function to get called whenever a resource is stopped
+   * @param resource_name The resource name to add to the stop listener.
+   * @param fn The function to call
+   */
+  add_to_resource_stop(resource_name, fn) {
+    this.#add_or_init(this.#on_resource_stop, resource_name, fn);
+  }
+  #call_for_resource(resource_fn_map, resource_name) {
+    const functions = resource_fn_map.get(resource_name);
+    if (functions) {
+      for (const fn of functions) {
+        fn();
+      }
+    }
+  }
+  @Event("onResourceStart")
+  on_resource_start(resource_name) {
+    this.#call_for_resource(this.#on_resource_start, resource_name);
+  }
+  @Event("onResourceStop")
+  on_resource_stop(resource_name) {
+    this.#call_for_resource(this.#on_resource_stop, resource_name);
+  }
+}
+if (!globalThis.RESOURCE_WRAPPER) {
+  globalThis.RESOURCE_WRAPPER = new ResourceWrapper();
+}
+const RESOURCE_WRAPPER = globalThis.RESOURCE_WRAPPER;
+const onResourceStart = /* @__PURE__ */ __name((resource, originalMethod) => {
+  if (GetResourceState(resource) === "started") {
+    setImmediate(() => originalMethod.call());
+  }
+  RESOURCE_WRAPPER.add_to_resource_start(resource, originalMethod);
+}, "onResourceStart");
+function OnResourceStart(resource = GetCurrentResourceName()) {
+  return /* @__PURE__ */ __name(function actualDecorator(originalMethod, context) {
+    if (context.private) {
+      throw new Error("OnResourceStart does not work on private types, please mark the field as public");
+    }
+    if (context.static) {
+      onResourceStart(resource, originalMethod);
+    } else {
+      context.addInitializer(function() {
+        onResourceStart(resource, originalMethod.bind(this));
+      });
+    }
+  }, "actualDecorator");
+}
+__name(OnResourceStart, "OnResourceStart");
+function OnResourceStop(resource = GetCurrentResourceName()) {
+  return /* @__PURE__ */ __name(function actualDecorator(originalMethod, context) {
+    if (context.private) {
+      throw new Error("OnResourceStop does not work on private types, please mark the field as public");
+    }
+    if (context.static) {
+      RESOURCE_WRAPPER.add_to_resource_stop(resource, originalMethod);
+    } else {
+      context.addInitializer(function() {
+        RESOURCE_WRAPPER.add_to_resource_stop(resource, originalMethod.bind(this));
+      });
+    }
+  }, "actualDecorator");
+}
+__name(OnResourceStop, "OnResourceStop");
+export {
+  OnResourceStart,
+  OnResourceStop
+};

package/common-game/common/decors/Ticks.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Gets called per server/client tick, this is asyncronous though, if you await
+ * in it, it will not be called until whatever was being awaited resolves.
+ */
+export declare function SetTick(): (originalMethod: any, context: ClassMethodDecoratorContext) => void;
+/**
+ * Gets called on the frame after the class is initialized.
+ */
+export declare function SetImmediate(): (originalMethod: any, context: ClassMethodDecoratorContext) => void;

package/common-game/common/decors/Ticks.js

@@ -0,0 +1,32 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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");
+function SetImmediate() {
+  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() {
+      setImmediate(async () => {
+        await originalMethod.call(this);
+      });
+    });
+  }, "actualDecorator");
+}
+__name(SetImmediate, "SetImmediate");
+export {
+  SetImmediate,
+  SetTick
+};

package/common-game/common/net/NetworkedMap.d.ts

@@ -0,0 +1,28 @@
+type ChangeListener<V> = (value: V) => 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][]);
+    get SyncName(): string;
+    private onPlayerDropped;
+    resync(source: number): void;
+    addSubscriber(source: number): void;
+    removeSubscriber(sub: number): boolean;
+    hasSubscriber(sub: number): boolean;
+    subscriberCount(): number;
+    private handleSync;
+    listenForChange(key: K, fn: ChangeListener<V>): void;
+    set(key: K, value: V): this;
+    clear(): void;
+    delete(key: K): boolean;
+    networkTick(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Unregisters from the tick handler and removes the event listener
+     */
+    dispose(): void;
+    get [Symbol.toStringTag](): string;
+}
+export {};

package/common-game/common/net/NetworkedMap.js

@@ -0,0 +1,225 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { GlobalData } from "../GlobalData";
+class NetworkedMapEventManager {
+  static {
+    __name(this, "NetworkedMapEventManager");
+  }
+  #syncedCalls = /* @__PURE__ */ new Map();
+  constructor() {
+    $SERVER: if (GlobalData.IS_SERVER) {
+      on("playerDropped", () => {
+        const src = source;
+        for (const [_k, map] of this.#syncedCalls) {
+          map.removeSubscriber(src);
+        }
+      });
+      return;
+    }
+    $CLIENT: {
+      RegisterResourceAsEventHandler(`${GlobalData.CurrentResource}:syncChanges`);
+      addRawEventListener(`${GlobalData.CurrentResource}:syncChanges`, (msgpack_data) => {
+        const data = msgpack_unpack(msgpack_data);
+        const syncName = data[0];
+        const syncData = data[1];
+        const map = this.#syncedCalls.get(syncName);
+        if (!map) {
+          throw new Error(`Tried to sync changes for a networked map but ${syncName} does't exist.`);
+        }
+        map.handleSync(syncData);
+      });
+    }
+  }
+  addNetworkedMap(map) {
+    this.#syncedCalls.set(map.SyncName, map);
+  }
+  removeNetworkedMap(syncName) {
+    this.#syncedCalls.delete(syncName);
+  }
+}
+const netManager = new NetworkedMapEventManager();
+class NetworkedMap 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() {
+    $CLIENT: if (GlobalData.IS_CLIENT) throw new Error(`Cannot call 'clear' on client`);
+    this.#queuedChanges = [];
+    this.#queuedChanges.push([3 /* Reset */]);
+    super.clear();
+  }
+  delete(key) {
+    $CLIENT: if (GlobalData.IS_CLIENT) throw new Error(`Cannot call 'delete' on client`);
+    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";
+  }
+}
+export {
+  NetworkedMap
+};

package/common-game/common/types.d.ts

@@ -0,0 +1,5 @@
+import type { Buffer } from "buffer";
+export type MsgpackBuffer = {
+    buffer: Buffer;
+    type: number;
+};