@nativewrappers/common 0.0.126 → 0.0.128

package/common-game/common/Command.js

@@ -0,0 +1,152 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { GlobalData } from "./GlobalData";
+const commands = [];
+$SERVER: {
+  on("playerJoining", () => emitNet("chat:addSuggestions", source, commands));
+}
+function registerCommand(name, commandHandler, restricted = true) {
+  if (Array.isArray(name)) {
+    for (const command of name) {
+      registerCommand(command, commandHandler, restricted);
+    }
+    return;
+  }
+  RegisterCommand(name, commandHandler, GlobalData.IS_CLIENT ? false : !!restricted);
+  $SERVER: {
+    const ace = `command.${name}`;
+    if (typeof restricted === "string") {
+      if (IsPrincipalAceAllowed(restricted, ace)) return;
+      return ExecuteCommand(`add_ace ${restricted} ${ace} allow`);
+    }
+    if (Array.isArray(restricted)) {
+      for (const principal of restricted) {
+        if (!IsPrincipalAceAllowed(principal, ace)) ExecuteCommand(`add_ace ${restricted} ${ace} allow`);
+      }
+    }
+  }
+}
+__name(registerCommand, "registerCommand");
+class Command {
+  /**
+   * Registers a new executable command with optional parameter validation and permission restrictions.
+   * @param name The unique identifier(s) for the command, either as a single string or an array of strings.
+   * @param handler The function to execute when the command is executed.
+   * @param help A description of the command, displayed as a chat suggestion.
+   * @param params An optional array of parameter definitions specifying the command's expected arguments,
+   *               including their names, types, and descriptive help text for chat suggestions.
+   * @param restricted Determines the command's access permissions:
+   *                   - Defaults to `true`, restricting usage to users with the "command.commandName" ACE permission.
+   *                   - A string such as `"group.admin"` grants the command permission to the specified principal.
+   *                   - An array of strings grants permission to multiple principals.
+   */
+  constructor(name, handler, help, params, restricted = true) {
+    this.name = name;
+    this.help = help;
+    this.params = params;
+    this.#handler = handler;
+    registerCommand(name, (source2, args, raw) => this.call(source2, args, raw), restricted);
+    if (params) {
+      for (const parameter of params) {
+        if (parameter.type) {
+          const defaultString = parameter.defaultValue !== void 0 ? `[default: ${parameter.defaultValue}]` : "";
+          const typeString = `[type: ${parameter.type}] ${defaultString}`;
+          parameter.help = parameter.help ? `${parameter.help} ${typeString}` : `${typeString}`;
+        }
+      }
+    }
+    setTimeout(() => {
+      const names = Array.isArray(name) ? name : [name];
+      for (const name2 of names) {
+        const commandObj = { ...this, name: `/${name2}` };
+        $SERVER: {
+          commands.push(commandObj);
+          emitNet("chat:addSuggestions", -1, commandObj);
+        }
+        $CLIENT: {
+          emit("chat:addSuggestion", commandObj);
+        }
+      }
+    }, 100);
+  }
+  static {
+    __name(this, "Command");
+  }
+  #handler;
+  /**
+   * Maps the arguments received from a command call to the defined parameters while validating the argument types.
+   * @param source The client that executed the command, or -1 if executed by the server.
+   * @param args The arguments passed to the command.
+   * @param raw The raw input string passed to the command.
+   * @returns A mapped object containing parsed parameters.
+   */
+  mapArguments(source2, args, raw) {
+    const mapped = {
+      source: source2,
+      raw
+    };
+    if (!this.params) return mapped;
+    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) {
+        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;
+        }
+      }
+      if (value === void 0 && (!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;
+  }
+  /**
+   * Executes the command with the given arguments and source, validating and mapping the arguments before calling the handler.
+   * @param source The client that executed the command.
+   * @param args The arguments passed to the command.
+   * @param raw The raw input string passed to the command.
+   */
+  async call(source2, args, raw = args.join(" ")) {
+    const parsed = this.mapArguments(source2, args, raw);
+    if (!parsed) return;
+    try {
+      await this.#handler(parsed);
+    } catch (err) {
+      Citizen.trace(`^1command '${raw.split(" ")[0] || raw}' failed to execute!^0
+${err.message}`);
+    }
+  }
+}
+export {
+  Command
+};

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

@@ -0,0 +1,13 @@
+export declare class Convar {
+    /**
+     * @returns the current console buffer
+     */
+    buffer(): string;
+    get(variable: string, defaultVar: string): string;
+    getInt(variable: string, defaultVar: number): number;
+    getFloat(varName: string, defaultVar: number): number;
+    getBool(varName: string, defaultVar: boolean): boolean;
+    set(variable: string, value: string): void;
+    setReplicated(variable: string, value: string): void;
+    setServerInfo(variable: string, value: string): void;
+}

package/common-game/common/Convar.js

@@ -0,0 +1,58 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { GlobalData } from "./GlobalData";
+class Convar {
+  static {
+    __name(this, "Convar");
+  }
+  /**
+   * @returns the current console buffer
+   */
+  buffer() {
+    $CLIENT: {
+      if (GlobalData.IS_CLIENT) {
+        throw new Error("This function isn't available on the client");
+      }
+    }
+    return GetConsoleBuffer();
+  }
+  get(variable, defaultVar) {
+    return GetConvar(variable, defaultVar);
+  }
+  getInt(variable, defaultVar) {
+    return GetConvarInt(variable, defaultVar);
+  }
+  getFloat(varName, defaultVar) {
+    return GetConvarFloat(varName, defaultVar);
+  }
+  getBool(varName, defaultVar) {
+    return GetConvarBool(varName, defaultVar);
+  }
+  set(variable, value) {
+    $CLIENT: {
+      if (GlobalData.IS_CLIENT) {
+        throw new Error("This function isn't available on the client");
+      }
+    }
+    SetConvar(variable, value);
+  }
+  setReplicated(variable, value) {
+    $CLIENT: {
+      if (GlobalData.IS_CLIENT) {
+        throw new Error("This function isn't available on the client");
+      }
+    }
+    SetConvarReplicated(variable, value);
+  }
+  setServerInfo(variable, value) {
+    $CLIENT: {
+      if (GlobalData.IS_CLIENT) {
+        throw new Error("This function isn't available on the client");
+      }
+    }
+    SetConvarServerInfo(variable, value);
+  }
+}
+export {
+  Convar
+};

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

@@ -0,0 +1,12 @@
+export declare class GlobalData {
+    static CurrentResource: string;
+    static GameName: string;
+    static GameBuild: number;
+    static IS_SERVER: boolean;
+    static IS_REDM: boolean;
+    static IS_FIVEM: boolean;
+    static IS_CLIENT: boolean;
+    static NetworkTick: number | null;
+    static NetworkedTicks: any[];
+    static EnablePrettyPrint: boolean;
+}

package/common-game/common/GlobalData.js

@@ -0,0 +1,20 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class GlobalData {
+  static {
+    __name(this, "GlobalData");
+  }
+  static CurrentResource = GetCurrentResourceName();
+  static GameName = GetGameName();
+  static GameBuild = GetGameBuildNumber();
+  static IS_SERVER = IsDuplicityVersion();
+  static IS_REDM = GetGameName() === "redm";
+  static IS_FIVEM = GetGameName() === "fivem";
+  static IS_CLIENT = !GlobalData.IS_SERVER;
+  static NetworkTick = null;
+  static NetworkedTicks = [];
+  static EnablePrettyPrint = true;
+}
+export {
+  GlobalData
+};

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

@@ -0,0 +1,69 @@
+type KvpSchema = Record<string, string | number | object>;
+type KvpObject<T> = T extends `${infer Prefix}.${infer Rest}` ? Rest extends `${string}.${string}` ? never : Prefix : never;
+type ValidJsonKey<Schema> = {
+    [K in keyof Schema]: K extends string ? `${K}.${string}` : never;
+}[keyof Schema];
+export declare class Kvp<Schema extends KvpSchema> {
+    /**
+     * Returns the value associated with a key as a number.
+     */
+    getNumber<K extends string & keyof Schema>(key: K): number;
+    /**
+     * Returns the value associated with a key as a float.
+     */
+    getFloat<K extends string & keyof Schema>(key: K): number;
+    /**
+     * Returns the value associated with a key as a string.
+     */
+    getString<K extends string & keyof Schema>(key: K): string | null;
+    /**
+     * Returns the value associated with a key as a parsed JSON string.
+     */
+    getJson<K extends string, O = KvpObject<K>>(key: K extends ValidJsonKey<O> ? K : never): (O extends string ? Schema[O] : null) | null;
+    /**
+     * Sets the value associated with a key as a number.
+     * @param async set the value using an async operation.
+     */
+    setNumber<K extends string & keyof Schema>(key: K, value: number, async?: boolean): void;
+    /**
+     * Sets the value associated with a key as a float.
+     * @param async set the value using an async operation.
+     */
+    setFloat<K extends string & keyof Schema>(key: K, value: number, async?: boolean): void;
+    /**
+     * Sets the value associated with a key as a string.
+     * @param async set the value using an async operation.
+     */
+    setString<K extends string & keyof Schema>(key: K, value: string, async?: boolean): void;
+    /**
+     * Sets the value associated with a key as a JSON string.
+     * @param async set the value using an async operation.
+     */
+    setJson<K extends string, O = KvpObject<K>>(key: K extends ValidJsonKey<O> ? K : never, value: O extends string ? Schema[O] : never, async?: boolean): void;
+    /**
+     * Sets the value associated with a key as a JSON string.
+     * @param async set the value using an async operation.
+     */
+    set<K extends string, O = KvpObject<K>>(key: K extends keyof Schema ? K : O extends string ? K : never, value: K extends keyof Schema ? Schema[K] : O extends string ? Schema[O] : never, async?: boolean): void;
+    /**
+     * Deletes the specified value for key.
+     * @param async remove the value using an async operation
+     */
+    delete(key: string, async?: boolean): void;
+    /**
+     * Commits pending asynchronous operations to disk, ensuring data consistency.
+     *
+     * Should be called after calling set methods using the async flag.
+     */
+    flush(): void;
+    getAllKeys(prefix: string): (keyof Schema)[];
+    /**
+     * Returns an array of keys which match or contain the given keys.
+     */
+    getKeys<K extends (string & keyof Schema) | string[]>(prefix: K): (keyof Schema)[];
+    /**
+     * Get all values from keys in an array as the specified type.
+     */
+    getValuesAsType<K extends (string & keyof Schema) | (string & keyof Schema)[]>(prefix: K, type: any): (string | number | Schema[string] | null)[];
+}
+export {};

package/common-game/common/Kvp.js

@@ -0,0 +1,137 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class Kvp {
+  static {
+    __name(this, "Kvp");
+  }
+  /**
+   * Returns the value associated with a key as a number.
+   */
+  getNumber(key) {
+    return GetResourceKvpInt(key);
+  }
+  /**
+   * Returns the value associated with a key as a float.
+   */
+  getFloat(key) {
+    return GetResourceKvpFloat(key);
+  }
+  /**
+   * Returns the value associated with a key as a string.
+   */
+  getString(key) {
+    return GetResourceKvpString(key);
+  }
+  /**
+   * Returns the value associated with a key as a parsed JSON string.
+   */
+  getJson(key) {
+    const str = GetResourceKvpString(key);
+    return str ? JSON.parse(str) : null;
+  }
+  /**
+   * Sets the value associated with a key as a number.
+   * @param async set the value using an async operation.
+   */
+  setNumber(key, value, async = false) {
+    return async ? SetResourceKvpIntNoSync(key, value) : SetResourceKvpInt(key, value);
+  }
+  /**
+   * Sets the value associated with a key as a float.
+   * @param async set the value using an async operation.
+   */
+  setFloat(key, value, async = false) {
+    return async ? SetResourceKvpFloatNoSync(key, value) : SetResourceKvpFloat(key, value);
+  }
+  /**
+   * Sets the value associated with a key as a string.
+   * @param async set the value using an async operation.
+   */
+  setString(key, value, async = false) {
+    return async ? SetResourceKvpNoSync(key, value) : SetResourceKvp(key, value);
+  }
+  /**
+   * Sets the value associated with a key as a JSON string.
+   * @param async set the value using an async operation.
+   */
+  setJson(key, value, async = false) {
+    const str = JSON.stringify(value);
+    return async ? SetResourceKvpNoSync(key, str) : SetResourceKvp(key, str);
+  }
+  /**
+   * Sets the value associated with a key as a JSON string.
+   * @param async set the value using an async operation.
+   */
+  set(key, value, async = false) {
+    switch (typeof value) {
+      case "function":
+      case "symbol":
+        throw new Error(`Failed to set Kvp for invalid type '${typeof value}'`);
+      case "undefined":
+        return this.delete(key, async);
+      case "object":
+        return this.setJson(key, value, async);
+      case "boolean":
+        value = value ? 1 : 0;
+      case "number":
+        return Number.isInteger(value) ? this.setNumber(key, value, async) : this.setFloat(key, value, async);
+      default:
+        value = String(value);
+        return this.setString(key, value, async);
+    }
+  }
+  /**
+   * Deletes the specified value for key.
+   * @param async remove the value using an async operation
+   */
+  delete(key, async = false) {
+    return async ? DeleteResourceKvpNoSync(key) : DeleteResourceKvp(key);
+  }
+  /**
+   * Commits pending asynchronous operations to disk, ensuring data consistency.
+   *
+   * Should be called after calling set methods using the async flag.
+   */
+  flush() {
+    FlushResourceKvp();
+  }
+  getAllKeys(prefix) {
+    const keys = [];
+    const handle = StartFindKvp(prefix);
+    if (handle === -1) return keys;
+    let key;
+    do {
+      key = FindKvp(handle);
+      if (key) keys.push(key);
+    } while (key);
+    EndFindKvp(handle);
+    return keys;
+  }
+  /**
+   * Returns an array of keys which match or contain the given keys.
+   */
+  getKeys(prefix) {
+    return typeof prefix === "string" ? this.getAllKeys(prefix) : prefix.flatMap((key) => this.getAllKeys(key));
+  }
+  /**
+   * Get all values from keys in an array as the specified type.
+   */
+  getValuesAsType(prefix, type) {
+    const values = this.getKeys(prefix);
+    return values.map((key) => {
+      switch (type) {
+        case "number":
+          return this.getNumber(key);
+        case "float":
+          return this.getFloat(key);
+        case "string":
+          return this.getString(key);
+        default:
+          return this.getJson(key);
+      }
+    });
+  }
+}
+export {
+  Kvp
+};

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

@@ -0,0 +1,14 @@
+export declare class Resource {
+    name: string;
+    constructor(name: string);
+    getMetadata(metadataKey: string, index: number): string;
+    getPath(): string;
+    loadFile(fileName: string): string;
+    saveFile(fileName: string, data: string, length: number): boolean;
+    scheduleTick(): void;
+    start(): void;
+    stop(): void;
+    static startResource(name: string): void;
+    static stopResource(name: string): void;
+    static resourceCount(): number;
+}

package/common-game/common/Resource.js

@@ -0,0 +1,54 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { GlobalData } from "./GlobalData";
+class Resource {
+  constructor(name) {
+    this.name = name;
+  }
+  static {
+    __name(this, "Resource");
+  }
+  getMetadata(metadataKey, index) {
+    return GetResourceMetadata(this.name, metadataKey, index);
+  }
+  getPath() {
+    return GetResourcePath(this.name);
+  }
+  loadFile(fileName) {
+    return LoadResourceFile(this.name, fileName);
+  }
+  saveFile(fileName, data, length) {
+    $CLIENT: {
+      if (GlobalData.IS_CLIENT) {
+        throw new Error("This function isn't available on the client");
+      }
+    }
+    return SaveResourceFile(this.name, fileName, data, length);
+  }
+  scheduleTick() {
+    $CLIENT: {
+      if (GlobalData.IS_CLIENT) {
+        throw new Error("This function isn't available on the client");
+      }
+    }
+    return ScheduleResourceTick(this.name);
+  }
+  start() {
+    StartResource(this.name);
+  }
+  stop() {
+    StopResource(this.name);
+  }
+  static startResource(name) {
+    StartResource(name);
+  }
+  static stopResource(name) {
+    StopResource(name);
+  }
+  static resourceCount() {
+    return GetNumResources();
+  }
+}
+export {
+  Resource
+};

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

@@ -0,0 +1,14 @@
+export declare enum ConVarType {
+    String = 0,
+    Integer = 1,
+    Float = 2,
+    Boolean = 3
+}
+type DeserializeFn<T> = (data: T) => unknown;
+/**
+ * Gets the specified `ConVar`s value, this will bind to the param.
+ * @param name the convar name
+ * @param is_floating_point if the convar is floating point, this should be explicitly set to true if your convar will be a float
+ */
+export declare function ConVar<T>(name: string, is_floating_point?: boolean, deserialize?: DeserializeFn<T>): (_initialValue: any, context: ClassFieldDecoratorContext, ..._args: any[]) => void;
+export {};

package/common-game/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-game/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;