@nativewrappers/redm 0.0.140 → 0.0.142

package/common/GlobalData.d.ts

@@ -4,9 +4,18 @@ export declare enum ErrorType {
     Export = 2,
     Nui = 3,
     Tick = 4,
-    Immediate = 5
+    Immediate = 5,
+    ConVar = 6
 }
 export type NativeWrapperErrorType = (type: ErrorType, err: Error) => void;
+export interface ErrorData {
+    name?: string;
+    source?: number;
+    args?: any | any[];
+}
+/**
+ * A static class containing useful
+ */
 export declare class GlobalData {
     static CurrentResource: string;
     static GameName: string;
@@ -17,6 +26,5 @@ export declare class GlobalData {
     static IS_CLIENT: boolean;
     static NetworkTick: number | null;
     static NetworkedTicks: any[];
-    static EnablePrettyPrint: boolean;
-    static OnError: (type: ErrorType, err: Error) => void;
+    static OnError: (type: ErrorType, err: Error, errorData: ErrorData) => void;
 }

package/common/GlobalData.js

@@ -7,9 +7,53 @@ var ErrorType = /* @__PURE__ */ ((ErrorType2) => {
   ErrorType2[ErrorType2["Nui"] = 3] = "Nui";
   ErrorType2[ErrorType2["Tick"] = 4] = "Tick";
   ErrorType2[ErrorType2["Immediate"] = 5] = "Immediate";
+  ErrorType2[ErrorType2["ConVar"] = 6] = "ConVar";
   return ErrorType2;
 })(ErrorType || {});
-globalThis.OnError = (type, err) => {
+function convertErrorTypeToName(errorType) {
+  switch (errorType) {
+    case 0 /* Event */:
+      return "Event";
+    case 1 /* NetEvent */:
+      return "Net Event";
+    case 2 /* Export */:
+      return "Export";
+    case 3 /* Nui */:
+      return "Nui";
+    case 4 /* Tick */:
+      return "Tick";
+    case 5 /* Immediate */:
+      return "Immediate";
+    case 6 /* ConVar */:
+      return "ConVar";
+  }
+}
+__name(convertErrorTypeToName, "convertErrorTypeToName");
+globalThis.ShouldParseErrorArgs = true;
+globalThis.FormatError = (errorType, err, errorData) => {
+  const errorName = convertErrorTypeToName(errorType);
+  console.error(`------- ${errorName} EVENT ERROR --------`);
+  const { name, source, args } = errorData;
+  if (name) {
+    console.error(`Call to ${name} errored`);
+  }
+  if (source) {
+    console.error(`Caller: ${source}`);
+  }
+  if (args && globalThis.ShouldParseErrorArgs) {
+    let jsonData;
+    try {
+      jsonData = JSON.stringify(args);
+    } catch {
+      jsonData = "Failed to convert args to JSON";
+    }
+    console.error(`Data: ${jsonData}`);
+  }
+  globalThis.printError(errorName, err);
+  console.error(`------- END ${errorName} EVENT ERROR --------`);
+};
+globalThis.OnError = (type, err, errorData) => {
+  globalThis.FormatError(type, err, errorData);
 };
 class GlobalData {
   static {
@@ -24,12 +68,11 @@ class GlobalData {
   static IS_CLIENT = !GlobalData.IS_SERVER;
   static NetworkTick = null;
   static NetworkedTicks = [];
-  static EnablePrettyPrint = true;
   /*
    * Called when one of the decors errors
    */
-  static OnError = /* @__PURE__ */ __name((type, err) => {
-    globalThis.OnError(type, err);
+  static OnError = /* @__PURE__ */ __name((type, err, errorData) => {
+    globalThis.OnError(type, err, errorData);
   }, "OnError");
 }
 export {

package/common/decors/ConVar.d.ts

@@ -4,11 +4,48 @@ export declare enum ConVarType {
     Float = 2,
     Boolean = 3
 }
-type DeserializeFn<T> = (data: T) => unknown;
+export type DeserializeFn = (data: unknown) => 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
+ * Gets the specified `ConVar`s value, this will bind to the parameter of the current class
+ * updating it whenever the ConVar value changes.
+ *
+ * Whatever the initial data value is will be the default value
+ *
+ * @param name - the convar name that we will read from
+ * @param convarType - the type of the convar
+ * @param deserialize - when using a string we can use this to automatically convert the value to a different structure,
+   this can also be used to know when a value gets changed, just make sure the value returns itself.
+ * @example
+ * ```typescript
+ * type Vec3 = [number, number, number];
+ * const deserializeToVec3Array = (data: string) => {
+ *   // convert a semicolon separate listed into a vector 3 array
+ *   const dataArray = data.split(";");
+ *   if (dataArray.length !== 3) {
+ *     throw new Error("ConVars data didn't have three numbers!");
+ *   }
+ *
+ *   return dataArray.map((v, i) => {
+ *     const converted = parseFloat(v.trim());
+ *     if (Number.isNaN(converted)) {
+ *       throw new Error(`Value at index ${i} was not an actual float!`);
+ *     }
+ *
+ *     return converted;
+ *   }) as Vec3;
+ * };
+ * class ConVar {
+ *   \@ConVar("nativeWrappers", ConVarType.Boolean)
+ *   private nativeWrappers = false; // false will be the default value
+ *
+ *   \@ConVar("engineDamageModifier", ConVarType.Float)
+ *   private engineDamageModifier = 1.0;
+ *
+ *   // If we `setr spawnPos "155.23;154.44;25.88"` this will convert the string into
+ *   // the specified type
+ *   \@ConVar("spawnPos", ConVarType.String, deserializeToVec3Array)
+ *   private vectorPos: Vec3 = [123.12, 123.22, 55];
+ * }
+ * ```
  */
-export declare function ConVar<T>(name: string, is_floating_point?: boolean, deserialize?: DeserializeFn<T>): (_initialValue: any, context: ClassFieldDecoratorContext, ..._args: any[]) => void;
-export {};
+export declare function ConVar(name: string, convarType: ConVarType, deserialize?: DeserializeFn): (_initialValue: any, context: ClassFieldDecoratorContext, ..._args: any[]) => void;

package/common/decors/ConVar.js

@@ -1,5 +1,6 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { ErrorType, GlobalData } from "../GlobalData";
 var ConVarType = /* @__PURE__ */ ((ConVarType2) => {
   ConVarType2[ConVarType2["String"] = 0] = "String";
   ConVarType2[ConVarType2["Integer"] = 1] = "Integer";
@@ -7,7 +8,7 @@ var ConVarType = /* @__PURE__ */ ((ConVarType2) => {
   ConVarType2[ConVarType2["Boolean"] = 3] = "Boolean";
   return ConVarType2;
 })(ConVarType || {});
-const get_convar_fn = /* @__PURE__ */ __name((con_var_type) => {
+const getConvarFunction = /* @__PURE__ */ __name((con_var_type) => {
   switch (con_var_type) {
     case 0 /* String */:
       return GetConvar;
@@ -21,44 +22,46 @@ const get_convar_fn = /* @__PURE__ */ __name((con_var_type) => {
     default:
   }
   throw new Error("Got invalid ConVarType");
-}, "get_convar_fn");
-function ConVar(name, is_floating_point, deserialize) {
+}, "getConvarFunction");
+function ConVar(name, convarType, 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 */;
+      const defaultValue = Reflect.get(t, context.name);
+      const conVarFunction = getConvarFunction(convarType);
+      const defaultType = typeof defaultValue;
+      if (defaultType !== "number" && defaultType !== "boolean" && defaultType !== "string") {
+        if (defaultType === "function") {
+          const error = new Error(
+            `${name} has a type of function, which isn't allowed for a ConVar. If you need to know when the data changes you can define a pass a deserializer.`
+          );
+          GlobalData.OnError(ErrorType.ConVar, error, { name });
+          return;
+        }
+        if (!deserialize) {
+          const error = new Error(
+            `${name} has a type of ${defaultType} which isn't allowed unless you define a deserializer.`
+          );
+          GlobalData.OnError(ErrorType.ConVar, error, { name });
+          return;
         }
-      } 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());
+      const getConvarValue = /* @__PURE__ */ __name(() => {
+        const value = conVarFunction(name, defaultValue);
+        try {
+          const returnData = deserialize ? deserialize(value) : value;
+          return returnData;
+        } catch (e) {
+          GlobalData.OnError(ErrorType.ConVar, e, { name: `${name}:DeserializeFn` });
+          throw e;
+        }
+      }, "getConvarValue");
+      Reflect.set(t, context.name, getConvarValue());
       AddConvarChangeListener(name, () => {
-        Reflect.set(t, context.name, get_convar_value());
+        Reflect.set(t, context.name, getConvarValue());
       });
     });
   }, "actualDecorator");

package/common/decors/Events.d.ts

@@ -1,41 +1,64 @@
-/**
- * Disables pretty printing in error messages
- */
-export declare const DisablePrettyPrint: () => boolean;
 /**
  * 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}
+ * All errors that happen inside of the event will automatically be caught, these will still
+ * output a FiveM stack trace.
+ *
+ * @note With all decors you can overwrite `globalThis.OnError` in order to hook into these errors to get more information or log them out to an external service, or to just disable the pretty printing.
  *
- * @param eventName the event to bind to
+ * @param eventName - the event to bind to
  */
 export declare function OnEvent(eventName: string): (originalMethod: any, context: ClassMethodDecoratorContext) => void;
+/**
+ * @deprecated use OnEvent instead, this will be removed upon 2.0
+ */
 export declare const Event: typeof OnEvent;
 /**
  * Registers the Net Event call for {@link eventName} to this method
  *
+ * All errors that happen inside of the event will automatically be caught, these will still
+ * output a FiveM stack trace.
  *
- * 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}
- *
+ * @note With all decors you can overwrite `globalThis.OnError` in order to hook into these errors to get more information or log them out to an external service, or to just disable the pretty printing.
  * @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 OnNetEvent(eventName: string, remoteOnly?: boolean): (originalMethod: any, context: ClassMethodDecoratorContext) => void;
+/**
+ * @deprecated Use `OnNetEvent` instead this will be removed upon 2.0
+ */
 export declare const NetEvent: typeof OnNetEvent;
 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
+ * Registers the NUI Event call for {@link 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
+ * There's two valid ways to return data into a callback
+ * 1. Returning in the method you're currently using will automatically call the callback
+ * 2. You can manually call the callback yourself
  *
+ * @note With all decors you can overwrite `globalThis.OnError` in order to hook into these errors to get more information or log them out to an external service, or to just disable the pretty printing.
  * @param eventName the event this will listen for
  * @param dontErrorWhenCbIsntInvoked this will just block the event fro merroring when the callback is never invoked.
+ * @throws This will throw if you don't call `cb` or return data in the method.
+ * If you move this call across task bounds and call the cb, this will still throw (say doing `setImmediate(() => cb("ok"));`)
+ * You can disable this by setting {@link dontErrorWhenCbIsntInvoked} to `true`
+ * @example
+ * ```typescript
+ * class NuiEventManager {
+ *   #is_ui_ready = false;
+ *   \@OnNuiEvent("ui_ready")
+ *   on_ui_ready(data: unknown, cb: NuiCallback) {
+ *     this.#is_ui_ready = true;
+ *     // will invoke the callback itself
+ *     return "ok";
+ *     // cb("ok"); // you can use this too
+ *   }
+ * }
+ * ```
  */
 export declare function OnNuiEvent(eventName: string, dontErrorWhenCbIsntInvoked?: boolean): (originalMethod: any, context: ClassMethodDecoratorContext) => void;
+/**
+ * @deprecated use OnNuiEvent instead
+ */
 export declare const NuiEvent: typeof OnNuiEvent;

package/common/decors/Events.js

@@ -1,7 +1,6 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 import { ErrorType, GlobalData } from "../GlobalData";
-const DisablePrettyPrint = /* @__PURE__ */ __name(() => GlobalData.EnablePrettyPrint = false, "DisablePrettyPrint");
 const AsyncFunction = (async () => {
 }).constructor;
 function OnEvent(eventName) {
@@ -14,15 +13,10 @@ function OnEvent(eventName) {
         try {
           return await originalMethod.call(this, ...args);
         } catch (e) {
-          GlobalData.OnError(ErrorType.Event, e);
-          REMOVE_EVENT_LOG: {
-            if (!GlobalData.EnablePrettyPrint) return;
-            console.error("------- EVENT ERROR --------");
-            console.error(`Call to ${eventName} errored`);
-            console.error(`Data: ${JSON.stringify(args)}`);
-            globalThis.printError("event", e);
-            console.error("------- END EVENT ERROR --------");
-          }
+          GlobalData.OnError(ErrorType.Event, e, {
+            name: eventName,
+            args
+          });
         }
       });
     });
@@ -63,16 +57,11 @@ function OnNetEvent(eventName, remoteOnly = true) {
           }
           return await originalMethod.call(this, ...args);
         } catch (e) {
-          GlobalData.OnError(ErrorType.NetEvent, 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)}`);
-            globalThis.printError("net event", e);
-            console.error("------- END NET EVENT ERROR --------");
-          }
+          GlobalData.OnError(ErrorType.NetEvent, e, {
+            name: eventName,
+            source: src,
+            args
+          });
         }
       });
     });
@@ -96,7 +85,7 @@ function OnNuiEvent(eventName, dontErrorWhenCbIsntInvoked = false) {
         try {
           retData = await originalMethod.call(this, data, cbWrapper);
         } catch (e) {
-          GlobalData.OnError(ErrorType.Nui, e);
+          GlobalData.OnError(ErrorType.Nui, e, { name: eventName });
           return;
         }
         if (!wasInvoked && !retData) {
@@ -115,7 +104,6 @@ function OnNuiEvent(eventName, dontErrorWhenCbIsntInvoked = false) {
 __name(OnNuiEvent, "OnNuiEvent");
 const NuiEvent = OnNuiEvent;
 export {
-  DisablePrettyPrint,
   Event,
   NetEvent,
   NuiEvent,

package/common/decors/Exports.d.ts

@@ -1 +1,4 @@
+/**
+ * Registers the export call for {@link exportName} to this method
+ */
 export declare function Exports(exportName: string): (originalMethod: any, context: ClassMethodDecoratorContext) => void;

package/common/decors/Exports.js

@@ -15,15 +15,7 @@ function Exports(exportName) {
           try {
             return await originalMethod.call(this, ...args);
           } catch (err) {
-            GlobalData.OnError(ErrorType.Export, 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 --------");
-            }
+            GlobalData.OnError(ErrorType.Export, err, { name: exportName });
             throw err;
           }
         }, "exportCb");
@@ -32,15 +24,7 @@ function Exports(exportName) {
           try {
             return originalMethod.call(this, ...args);
           } catch (err) {
-            GlobalData.OnError(ErrorType.Export, 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 --------");
-            }
+            GlobalData.OnError(ErrorType.Export, err, { name: exportName });
             throw err;
           }
         }, "exportCb");

package/common/decors/Resources.d.ts

@@ -4,7 +4,8 @@ type FunctionCall = (resource_name?: string) => void;
 declare class ResourceWrapper {
     #private;
     /**
-     * Adds a function to get called whenever a resource is started
+     * Adds a function to get called whenever a resource is started, if the current
+     * {@link resource_name} is started then it will immediately call the function.
      * @param resource_name The resource name to add to the start listener.
      * @param fn The function to call
      */

package/common/decors/Resources.js

@@ -20,7 +20,8 @@ class ResourceWrapper {
     }
   }
   /**
-   * Adds a function to get called whenever a resource is started
+   * Adds a function to get called whenever a resource is started, if the current
+   * {@link resource_name} is started then it will immediately call the function.
    * @param resource_name The resource name to add to the start listener.
    * @param fn The function to call
    */
@@ -28,6 +29,9 @@ class ResourceWrapper {
     if (resource_name === "global") {
       this.#global_on_resource_start.push(fn);
     } else {
+      if (GetResourceState(resource_name) === "started") {
+        setImmediate(() => fn(resource_name));
+      }
       this.#add_or_init(this.#on_resource_start, resource_name, fn);
     }
   }
@@ -80,22 +84,16 @@ const GetResourceWrapper = /* @__PURE__ */ __name(() => {
 }, "GetResourceWrapper");
 EnsureResourceWrapperInit();
 const RESOURCE_WRAPPER = globalThis.RESOURCE_WRAPPER;
-const onResourceStart = /* @__PURE__ */ __name((resource, originalMethod) => {
-  if (resource !== "global" && 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);
+      RESOURCE_WRAPPER.add_to_resource_start(resource, originalMethod);
     } else {
       context.addInitializer(function() {
-        onResourceStart(resource, originalMethod.bind(this));
+        RESOURCE_WRAPPER.add_to_resource_start(resource, originalMethod.bind(this));
       });
     }
   }, "actualDecorator");

package/common/decors/Ticks.d.ts

@@ -1,9 +1,16 @@
 /**
  * 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.
+ * @param contextName - used whenever the function errors, will provide context to the tick
  */
-export declare function SetTick(): (originalMethod: any, context: ClassMethodDecoratorContext) => void;
+export declare function OnTick(contextName: string): (originalMethod: any, context: ClassMethodDecoratorContext) => void;
+/**
+ * @see OnTick
+ */
+export declare const SetTick: typeof OnTick;
 /**
  * Gets called on the frame after the class is initialized.
+ * @param contextName - used whenever the function errors, will provide context to the function
  */
-export declare function SetImmediate(): (originalMethod: any, context: ClassMethodDecoratorContext) => void;
+export declare function OnInit(contextName: string): (originalMethod: any, context: ClassMethodDecoratorContext) => void;
+export declare const SetImmediate: typeof OnInit;

package/common/decors/Ticks.js

@@ -1,7 +1,7 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 import { ErrorType, GlobalData } from "../GlobalData";
-function SetTick() {
+function OnTick(contextName) {
   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");
@@ -11,14 +11,15 @@ function SetTick() {
         try {
           await originalMethod.call(this);
         } catch (e) {
-          GlobalData.OnError(ErrorType.Tick, e);
+          GlobalData.OnError(ErrorType.Tick, e, contextName ? { name: contextName } : {});
         }
       });
     });
   }, "actualDecorator");
 }
-__name(SetTick, "SetTick");
-function SetImmediate() {
+__name(OnTick, "OnTick");
+const SetTick = OnTick;
+function OnInit(contextName) {
   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");
@@ -28,14 +29,17 @@ function SetImmediate() {
         try {
           await originalMethod.call(this);
         } catch (e) {
-          GlobalData.OnError(ErrorType.Immediate, e);
+          GlobalData.OnError(ErrorType.Tick, e, contextName ? { name: contextName } : {});
         }
       });
     });
   }, "actualDecorator");
 }
-__name(SetImmediate, "SetImmediate");
+__name(OnInit, "OnInit");
+const SetImmediate = OnInit;
 export {
+  OnInit,
+  OnTick,
   SetImmediate,
   SetTick
 };

package/common/utils/BitSet.d.ts

@@ -0,0 +1,26 @@
+/**
+ * A basic bitset wrapper to make some bitset code reusable
+ */
+export declare class BitSet {
+    private value;
+    /**
+     * Sets the bit at {@param position} to `1`
+     */
+    set(position: number): void;
+    /**
+     * Sets the bit at {@param position} to `0`
+     */
+    clear(position: number): void;
+    /**
+     * Toggles the bit at {@param position}
+     */
+    toggle(position: number): void;
+    /**
+     * @returns `true` if the bit at {@param position} is set.
+     */
+    test(position: number): number;
+    /**
+     * @returns `true` if no bits in the bitset are set, false otherwise.
+     */
+    isEmpty(): boolean;
+}

package/common/utils/BitSet.js

@@ -0,0 +1,41 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class BitSet {
+  static {
+    __name(this, "BitSet");
+  }
+  value = 0;
+  /**
+   * Sets the bit at {@param position} to `1`
+   */
+  set(position) {
+    this.value |= 1 << position;
+  }
+  /**
+   * Sets the bit at {@param position} to `0`
+   */
+  clear(position) {
+    this.value &= ~(1 << position);
+  }
+  /**
+   * Toggles the bit at {@param position}
+   */
+  toggle(position) {
+    this.value ^= 1 << position;
+  }
+  /**
+   * @returns `true` if the bit at {@param position} is set.
+   */
+  test(position) {
+    return this.value & position;
+  }
+  /**
+   * @returns `true` if no bits in the bitset are set, false otherwise.
+   */
+  isEmpty() {
+    return this.value === 0;
+  }
+}
+export {
+  BitSet
+};

package/index.d.ts

@@ -80,6 +80,7 @@ export * from "./common/GlobalData";
 export * from "./common/Kvp";
 export * from "./common/Resource";
 export * from "./common/types";
+export * from "./common/utils/BitSet";
 export * from "./common/utils/ClassTypes";
 export * from "./common/utils/Color";
 export * from "./common/utils/Delay";

package/index.js

@@ -80,6 +80,7 @@ export * from "./common/GlobalData";
 export * from "./common/Kvp";
 export * from "./common/Resource";
 export * from "./common/types";
+export * from "./common/utils/BitSet";
 export * from "./common/utils/ClassTypes";
 export * from "./common/utils/Color";
 export * from "./common/utils/Delay";

package/package.json

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