@nativewrappers/common 0.0.44

package/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/Convar.js

@@ -0,0 +1,50 @@
+import { GlobalData } from "./GlobalData";
+export class 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);
+    }
+}

package/GlobalData.d.ts

@@ -0,0 +1,6 @@
+export declare class GlobalData {
+    static IS_SERVER: boolean;
+    static IS_CLIENT: boolean;
+    static NetworkTick: number | null;
+    static NetworkedTicks: any[];
+}

package/GlobalData.js

@@ -0,0 +1,6 @@
+export class GlobalData {
+    static IS_SERVER = IsDuplicityVersion();
+    static IS_CLIENT = !GlobalData.IS_SERVER;
+    static NetworkTick = null;
+    static NetworkedTicks = [];
+}

package/Kvp.d.ts

@@ -0,0 +1,91 @@
+export declare class Kvp {
+    /**
+     * Sets the resource key to the specified value this is a blocking operation, if you're doing large write operations you should use [[setKvpAsync]] instead.
+     * @param key the key string
+     * @param value the value to set the key to
+     */
+    setKvp<T = number | string>(key: string, value: T): void;
+    /**
+     * Sets the resource key to the specified value, this doesn't immediately write to disk and needs [[flush]] called afterwards.
+     * @param key the key string
+     * @param value the value to set the key to
+     */
+    setKvpAsync<T = number | string>(key: string, value: T): void;
+    /**
+     * Sets the specified key to the specified json value
+     * This can error if given an invalid object
+     * @param key the key string
+     * @param value the value to set the key to
+     */
+    setKvpJson(key: string, value: any): void;
+    /**
+     * Gets the specified value for key
+     * @param key the key of the value to get
+     * @returns a string, or null if there is no value
+     */
+    getKvpString(key: string): string | null;
+    /**
+     * Gets the specified value for key
+     * @param key the key of the value to get
+     * @returns the value stored, as a number, or 0 if there is no value
+     */
+    getKvpNumber(key: string): number;
+    /**
+     * Gets the specified value for key
+     * @param key the key of the value to get
+     * @returns the value stored as a float, or 0.0 if there is no value
+     */
+    getKvpFloat(key: string): number;
+    getKvpJson<T>(key: string): T;
+    /**
+     * Deletes the specified value for key, this is a blocking operation, if you're deleting a bunch of keys you should use [[deleteAsync]]
+     * @param key the key of the value to delete
+     */
+    delete(key: string): void;
+    /**
+     * Deletes the specified resource keys value, this doesn't immediately write to disk and needs [[flush]] called afterwards.
+     * @param key the key to delete
+     */
+    deleteAsync(key: string): void;
+    /**
+     * Ensures that any previous async call is flushed to disk
+     */
+    flush(): void;
+    private handleKvp;
+    /**
+     * enumerates over any kvp prefixed with the prefix
+     *
+     * ```typescript
+     * for (const value of Kvp.getKvpsAsString("native:")) {
+     *		console.log(value);
+     * }
+     * ```
+     *
+     * @param prefix the prefix to search for
+     */
+    getKvpsAsString(prefix: string): IterableIterator<string>;
+    /**
+     * enumerates over any kvp prefixed with the prefix
+     *
+     * ```typescript
+     * for (const value of Kvp.getKvpsAsNumber("native:")) {
+     *		console.log(value);
+     * }
+     * ```
+     *
+     * @param prefix the prefix to search for
+     */
+    getKvpsAsNumber(prefix: string): IterableIterator<number>;
+    /**
+     * enumerates over any kvp prefixed with the prefix
+     *
+     * ```typescript
+     * for (const value of Kvp.getKvpsAsFloat("native:")) {
+     *		console.log(value);
+     * }
+     * ```
+     *
+     * @param prefix the prefix to search for
+     */
+    getKvpsAsFloat(prefix: string): IterableIterator<number>;
+}

package/Kvp.js

@@ -0,0 +1,161 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export class Kvp {
+    // TODO: Find a way to do this without casting to any
+    /**
+     * Sets the resource key to the specified value this is a blocking operation, if you're doing large write operations you should use [[setKvpAsync]] instead.
+     * @param key the key string
+     * @param value the value to set the key to
+     */
+    setKvp(key, value) {
+        const type = typeof value;
+        if (type === "string") {
+            SetResourceKvp(key, value);
+        }
+        else {
+            if (Number.isInteger(value)) {
+                SetResourceKvpInt(key, value);
+            }
+            else {
+                SetResourceKvpFloat(key, value);
+            }
+        }
+    }
+    /**
+     * Sets the resource key to the specified value, this doesn't immediately write to disk and needs [[flush]] called afterwards.
+     * @param key the key string
+     * @param value the value to set the key to
+     */
+    setKvpAsync(key, value) {
+        const type = typeof value;
+        if (type === "string") {
+            SetResourceKvpNoSync(key, value);
+        }
+        else {
+            if (Number.isInteger(value)) {
+                SetResourceKvpIntNoSync(key, value);
+            }
+            else {
+                SetResourceKvpFloatNoSync(key, value);
+            }
+        }
+    }
+    /**
+     * Sets the specified key to the specified json value
+     * This can error if given an invalid object
+     * @param key the key string
+     * @param value the value to set the key to
+     */
+    setKvpJson(key, value) {
+        const stringified = JSON.stringify(value);
+        this.setKvp(key, stringified);
+    }
+    /**
+     * Gets the specified value for key
+     * @param key the key of the value to get
+     * @returns a string, or null if there is no value
+     */
+    getKvpString(key) {
+        return GetResourceKvpString(key);
+    }
+    /**
+     * Gets the specified value for key
+     * @param key the key of the value to get
+     * @returns the value stored, as a number, or 0 if there is no value
+     */
+    getKvpNumber(key) {
+        return GetResourceKvpInt(key);
+    }
+    /**
+     * Gets the specified value for key
+     * @param key the key of the value to get
+     * @returns the value stored as a float, or 0.0 if there is no value
+     */
+    getKvpFloat(key) {
+        return GetResourceKvpFloat(key);
+    }
+    getKvpJson(key) {
+        const kvp = this.getKvpString(key);
+        return JSON.parse(kvp || "{}");
+    }
+    /**
+     * Deletes the specified value for key, this is a blocking operation, if you're deleting a bunch of keys you should use [[deleteAsync]]
+     * @param key the key of the value to delete
+     */
+    delete(key) {
+        DeleteResourceKvp(key);
+    }
+    /**
+     * Deletes the specified resource keys value, this doesn't immediately write to disk and needs [[flush]] called afterwards.
+     * @param key the key to delete
+     */
+    deleteAsync(key) {
+        DeleteResourceKvpNoSync(key);
+    }
+    /**
+     * Ensures that any previous async call is flushed to disk
+     */
+    flush() {
+        FlushResourceKvp();
+    }
+    *handleKvp(prefix, iterType) {
+        const handle = StartFindKvp(prefix);
+        if (handle === -1)
+            return;
+        let key;
+        do {
+            key = FindKvp(handle);
+            if (iterType === "string") {
+                yield GetResourceKvpString(key);
+            }
+            else if (iterType === "number") {
+                yield GetResourceKvpInt(key);
+            }
+            else if (iterType === "float") {
+                yield GetResourceKvpFloat(key);
+            }
+        } while (key);
+        EndFindKvp(handle);
+    }
+    /**
+     * enumerates over any kvp prefixed with the prefix
+     *
+     * ```typescript
+     * for (const value of Kvp.getKvpsAsString("native:")) {
+     *		console.log(value);
+     * }
+     * ```
+     *
+     * @param prefix the prefix to search for
+     */
+    getKvpsAsString(prefix) {
+        return this.handleKvp(prefix, "string");
+    }
+    /**
+     * enumerates over any kvp prefixed with the prefix
+     *
+     * ```typescript
+     * for (const value of Kvp.getKvpsAsNumber("native:")) {
+     *		console.log(value);
+     * }
+     * ```
+     *
+     * @param prefix the prefix to search for
+     */
+    getKvpsAsNumber(prefix) {
+        return this.handleKvp(prefix, "number");
+    }
+    /**
+     * enumerates over any kvp prefixed with the prefix
+     *
+     * ```typescript
+     * for (const value of Kvp.getKvpsAsFloat("native:")) {
+     *		console.log(value);
+     * }
+     * ```
+     *
+     * @param prefix the prefix to search for
+     */
+    getKvpsAsFloat(prefix) {
+        return this.handleKvp(prefix, "float");
+    }
+}

package/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/Resource.js

@@ -0,0 +1,47 @@
+import { GlobalData } from "./GlobalData";
+export class Resource {
+    name;
+    constructor(name) {
+        this.name = name;
+    }
+    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();
+    }
+}

package/decors/Events.d.ts

@@ -0,0 +1,14 @@
+export declare enum ConVarType {
+    String = 0,
+    Integer = 1,
+    Float = 2,
+    Boolean = 3
+}
+export declare function Exports(exportName: string): (originalMethod: any, context: ClassMethodDecoratorContext) => void;
+export declare function Event(eventName: string): (originalMethod: any, context: ClassMethodDecoratorContext) => void;
+export declare function NetEvent(eventName: string, remoteOnly?: boolean): (originalMethod: any, context: ClassMethodDecoratorContext) => void;
+export declare function NuiEvent(eventName: string): (originalMethod: any, context: ClassMethodDecoratorContext) => void;
+type DeserializeFn<T> = (data: T) => unknown;
+export declare function ConVar<T>(name: string, is_floating_point?: boolean, deserialize?: DeserializeFn<T>): (_initialValue: any, context: ClassFieldDecoratorContext, ...args: any[]) => void;
+export declare function SetTick(): (originalMethod: any, context: ClassMethodDecoratorContext) => void;
+export {};

package/decors/Events.js

@@ -0,0 +1,167 @@
+export var ConVarType;
+(function (ConVarType) {
+    ConVarType[ConVarType["String"] = 0] = "String";
+    ConVarType[ConVarType["Integer"] = 1] = "Integer";
+    ConVarType[ConVarType["Float"] = 2] = "Float";
+    ConVarType[ConVarType["Boolean"] = 3] = "Boolean";
+})(ConVarType || (ConVarType = {}));
+// TODO: Have a way to clean all of this up (maybe hook Symbol.disposable
+// somehow?)
+/*
+ * Registers the export call for {exportName} to this method
+ */
+export function Exports(exportName) {
+    return 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 () {
+            const t = this;
+            exports(exportName, (...args) => {
+                return originalMethod.call(t, ...args);
+            });
+        });
+    };
+}
+/*
+ * Registers the Event call for {eventName} to this method
+ */
+export function Event(eventName) {
+    return 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 t = this;
+            on(eventName, (...args) => {
+                return originalMethod.call(t, ...args);
+            });
+        });
+    };
+}
+/*
+ * Registers the Net Event call for {eventName} to this method
+ */
+export function NetEvent(eventName, remoteOnly = false) {
+    return 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, (...args) => {
+                CLIENT: {
+                    if (remoteOnly && source !== 65535) {
+                        return;
+                    }
+                }
+                return originalMethod.call(t, ...args);
+            });
+        });
+    };
+}
+/*
+ * Registers the NUI Event call for {eventName} to this method, the function signature
+ * should be (data: unknown, cb: (data?: any) => void) => void
+ * You shoud always execute `cb` with '' if you don't want to send data back to
+ * the UI, otherwise you'll cause a network error for the `fetch` request
+ */
+export function NuiEvent(eventName) {
+    return 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 () {
+            const t = this;
+            RegisterNuiCallback(eventName, (...args) => {
+                return originalMethod.call(t, ...args);
+            });
+        });
+    };
+}
+const get_convar_fn = (con_var_type) => {
+    switch (con_var_type) {
+        case ConVarType.String:
+            return GetConvar;
+        case ConVarType.Integer:
+            return GetConvarInt;
+        case ConVarType.Float:
+            return GetConvarFloat;
+        case ConVarType.Boolean:
+            return GetConvarBool;
+    }
+    // never guess people wont manage to hit this
+    throw new Error("Got invalid ConVarType");
+};
+/*
+ * Gets the specified `ConVar`s value, do note that if you *expect* the convar
+ * to be a float you should explicitly set is_floating_point, otherwise some
+ * bundlers will remove the float
+ */
+export function ConVar(name, is_floating_point, deserialize) {
+    // the implementation shows that this will be _initialValue, but it doesn't
+    // seem to actually be???
+    return 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 = ConVarType.Float;
+                }
+                else {
+                    con_var_type = ConVarType.Integer;
+                }
+            }
+            else if (default_type == "boolean") {
+                con_var_type = ConVarType.Boolean;
+            }
+            else if (default_value == "string") {
+                con_var_type = ConVarType.String;
+            }
+            // if we're not set that means our default value was not valid, and likely
+            // undefined (which we should just get rid of) or an object, and the
+            // caller should send a deserialize function to work with.
+            if (!deserialize && con_var_type === null) {
+                throw new Error("You should provide a deserialize function if you want to convert this to an object type");
+            }
+            // if we got past our previous check then we're going to take the data as
+            // a string and pass it to the deserialize function
+            if (con_var_type === null) {
+                con_var_type = ConVarType.String;
+            }
+            const con_var_fn = get_convar_fn(con_var_type);
+            // nice and easy wrapper
+            const get_convar_value = () => {
+                const data = con_var_fn(name, default_value);
+                return deserialize ? deserialize(data) : data;
+            };
+            Reflect.set(t, context.name, get_convar_value());
+            AddConvarChangeListener(name, (con_var_name) => {
+                Reflect.set(t, context.name, get_convar_value());
+            });
+        });
+    };
+}
+/*
+ * 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 function SetTick() {
+    return 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 () {
+            const t = this;
+            setTick(async () => {
+                await originalMethod.call(t);
+            });
+        });
+    };
+}

package/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./utils";
+export * from "./net/NetworkedMap";
+export * from "./decors/Events";
+export * from "./Convar";
+export * from "./Kvp";
+export * from "./Resource";
+export * from "./utils/index";

package/index.js

@@ -0,0 +1,7 @@
+export * from "./utils";
+export * from "./net/NetworkedMap";
+export * from "./decors/Events";
+export * from "./Convar";
+export * from "./Kvp";
+export * from "./Resource";
+export * from "./utils/index";

package/net/NetworkedMap.d.ts

@@ -0,0 +1,23 @@
+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][]);
+    private onPlayerDropped;
+    addSubscriber(sub: number): void;
+    removeSubscriber(sub: number): boolean;
+    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 {};