@nativewrappers/common-game 0.0.125 → 0.0.127

package/common/decors/ConVar.js

@@ -0,0 +1,70 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 || {});
+const 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_type === "string") {
+        con_var_type = 0 /* String */;
+      }
+      if (!deserialize && con_var_type === null) {
+        throw new Error(
+          `Failed to determine what to use to deserialize '${name}' was for var had type '${default_type}' which can't be deserialized without providing your own deserialize function.`
+        );
+      }
+      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");
+export {
+  ConVar,
+  ConVarType
+};

package/common/decors/Events.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Disables pretty printing in error messages
+ */
+export declare const DisablePrettyPrint: () => boolean;
+export declare enum Binding {
+    /**
+     * No one can call this
+     */
+    None = 0,
+    /**
+     * Server only accepts server calls, client only client calls
+     */
+    Local = 1,
+    /**
+     * Server only accepts client calls, client only server calls
+     */
+    Remote = 2,
+    /**
+     * Accept all incoming calls
+     * Server only accepts client calls, client only server calls
+     */
+    All = 3
+}
+/**
+ * Registers the Event call for {@link eventName} to this method.
+ *
+ * This has internal pretty-printing to make errors easier to track, if
+ * you want to disable this you will need to call {@link DisablePrettyPrint}, or if you're
+ * using esbuild you can add `REMOVE_EVENT_LOG` to your drop label {@link https://esbuild.github.io/api/#drop-labels}
+ * @param eventName the event to bind to
+ */
+export declare function CfxEvent(eventName: string, binding?: Binding): (originalMethod: any, context: ClassMethodDecoratorContext) => void;
+/**
+ * Registers the Event call for {@link eventName} to this method.
+ *
+ * This has internal pretty-printing to make errors easier to track, if
+ * you want to disable this you will need to call {@link DisablePrettyPrint}, or if you're
+ * using esbuild you can add `REMOVE_EVENT_LOG` to your drop label {@link https://esbuild.github.io/api/#drop-labels}
+ *
+ * @param eventName the event to bind to
+ */
+export declare function Event(eventName: string): (originalMethod: any, context: ClassMethodDecoratorContext) => void;
+/**
+ * Registers the Net Event call for {@link eventName} to this method
+ *
+ *
+ * This has internal pretty-printing to make errors easier to track, if
+ * you want to disable this you will need to call {@link DisablePrettyPrint}, or if you're
+ * using esbuild you can add `REMOVE_EVENT_LOG` to your drop label {@link https://esbuild.github.io/api/#drop-labels}
+ *
+ * @param eventName the event to bind this net event to
+ * @param remoteOnly if the event should only accept remote calls, if set to true it will ignore any local call via `emit`, defaults to true
+ */
+export declare function NetEvent(eventName: string, remoteOnly?: boolean): (originalMethod: any, context: ClassMethodDecoratorContext) => void;
+export type NuiCallback = (data: string) => void;
+/**
+ * Registers the NUI Event call for {eventName} to this method, the function signature
+ * will always be (data: unknown, cb: (data?: any) => void) => void
+ *
+ * There's two valid ways to return data into a callback, returning in the method
+ * you're currently using will automatically call the callback, or you can manually call the callback yourself
+ *
+ * @param eventName the event this will listen for
+ * @param dontErrorWhenCbIsntInvoked this will just block the event fro merroring when the callback is never invoked.
+ */
+export declare function NuiEvent(eventName: string, dontErrorWhenCbIsntInvoked?: boolean): (originalMethod: any, context: ClassMethodDecoratorContext) => void;

package/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/decors/Exports.d.ts

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

package/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/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/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/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/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/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/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/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 {};