@trippler/tr_lib 2.0.9 → 2.0.11

package/client/index.d.ts

@@ -1,3 +1,3 @@
-export * from './async/promise';
-export * from './async/listen';
+export * from './promise/onPromise';
+export * from './promise/triggerPromise';
 export * from '../shared/console';

package/client/index.js

@@ -1,3 +1,3 @@
-export * from './async/promise';
-export * from './async/listen';
+export * from './promise/onPromise';
+export * from './promise/triggerPromise';
 export * from '../shared/console';

package/client/promise/onPromise/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: true;
+export default _default;

package/client/promise/onPromise/index.js

@@ -0,0 +1 @@
+export default true;

package/client/promise/triggerPromise/index.d.ts

@@ -0,0 +1 @@
+export declare const triggerPromise: <T = unknown>(options: [number, boolean] | number | boolean | string, endpoint: string | any, ...parameters: any[]) => Promise<T | null>;

package/client/promise/triggerPromise/index.js

@@ -0,0 +1,78 @@
+import { trace, fatal } from '../../../shared/console';
+const pendingPromises = {};
+const patienceLimit = 5000;
+const averageServerResponseTime = 1000;
+const promises = [];
+let promiseId = 0;
+export const triggerPromise = async (options, endpoint, ...parameters) => {
+    if (typeof options === 'string') {
+        return triggerPromise([patienceLimit, false], options, endpoint, ...parameters);
+    }
+    if (typeof options === 'number') {
+        return triggerPromise([options, false], endpoint, ...parameters);
+    }
+    if (typeof options === 'boolean') {
+        return triggerPromise([patienceLimit, options], endpoint, ...parameters);
+    }
+    await new Promise(resolve => {
+        if (!promises.includes(endpoint)) {
+            const handler = (defined) => {
+                removeEventListener('__tr_promise_self_server_response', handler);
+                if (!defined) {
+                    fatal(`promise ${endpoint} is not defined`);
+                    resolve(false);
+                    return;
+                }
+                promises.push(endpoint);
+                resolve(true);
+            };
+            onNet('__tr_promise_self_server_response', handler);
+            emitNet('__tr_promise_self_request_server', endpoint);
+            setTimeout(() => {
+                removeEventListener('__tr_promise_self_server_response', handler);
+                resolve(false);
+            }, averageServerResponseTime);
+        }
+        else
+            resolve(true);
+    });
+    const timeout = options[0] ?? patienceLimit;
+    const debug = options[1] ?? false;
+    const promise = () => {
+        return new Promise(resolve => {
+            promiseId = promiseId + 1;
+            const currentPromiseId = promiseId;
+            pendingPromises[currentPromiseId] = { resolve };
+            const responseEvent = `__tr_promise_await:${endpoint}`;
+            if (!promises.includes(endpoint)) {
+                promises.push(endpoint);
+                onNet(responseEvent, (selfpromiseId, response) => {
+                    if (pendingPromises[selfpromiseId]) {
+                        pendingPromises[selfpromiseId].resolve({ success: true, returned: response });
+                        delete pendingPromises[selfpromiseId];
+                    }
+                });
+            }
+            emitNet(`__tr_promise_on:${endpoint}`, currentPromiseId, ...parameters);
+            setTimeout(() => {
+                if (pendingPromises[currentPromiseId]) {
+                    pendingPromises[currentPromiseId].resolve({ success: false });
+                    delete pendingPromises[currentPromiseId];
+                }
+            }, timeout);
+        });
+    };
+    const response = await promise();
+    if (response.success) {
+        if (debug) {
+            trace(`server promise ${endpoint} returned ${Object.keys(response.returned).length} values`);
+        }
+        return response.returned;
+    }
+    else {
+        if (debug) {
+            trace(`server promise ${endpoint} timed out after ${timeout}ms`);
+        }
+    }
+    return null;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trippler/tr_lib",
-  "version": "2.0.9",
+  "version": "2.0.11",
   "description": "A lightweight utility & helper library for FiveM developers. Designed to improve code reusability, consistency, and performance across and outcross Trippler resources.",
   "author": "Trippler",
   "license": "GPL-3.0",

package/server/index.d.ts

@@ -1,3 +1,3 @@
-export * from './async/promise';
-export * from './async/listen';
+export * from './promise/onPromise';
+export * from './promise/triggerPromise';
 export * from '../shared/console';

package/server/index.js

@@ -1,3 +1,3 @@
-export * from './async/promise';
-export * from './async/listen';
+export * from './promise/onPromise';
+export * from './promise/triggerPromise';
 export * from '../shared/console';

package/server/promise/onPromise/index.d.ts

@@ -0,0 +1 @@
+export declare const onPromise: <T extends (...args: any) => ReturnType<T>>(endpoint: string, Function: T) => boolean;

package/server/promise/onPromise/index.js

@@ -0,0 +1,32 @@
+import { fatal } from '../../../shared/console';
+const promises = [];
+onNet('__tr_promise_self_request_server', (endpoint) => {
+    emitNet('__tr_promise_self_server_response', source, promises.includes(endpoint));
+});
+onNet('__tr_promise_on_self_server_lua_backward_compatibility', (endpoint) => {
+    promises.push(endpoint);
+});
+export const onPromise = (endpoint, Function) => {
+    if (typeof endpoint !== 'string')
+        return false;
+    if (promises.includes(endpoint)) {
+        fatal(`server promise '${endpoint}' is already defined`);
+        return false;
+    }
+    if (typeof Function !== 'function')
+        return false;
+    promises.push(endpoint);
+    emitNet('__tr_promise_on_self_server_ts_backward_compatibility', source, endpoint);
+    onNet(`__tr_promise_on:${endpoint}`, (promiseId, ...parameters) => {
+        const clientSource = source;
+        try {
+            const result = Function(clientSource, ...parameters);
+            emitNet(`__tr_promise_on:${endpoint}`, source, promiseId, result);
+        }
+        catch (error) {
+            emitNet(`__tr_promise_on:${endpoint}`, source, promiseId);
+            console.trace(`server promise '${endpoint}' (client ${source}) threw error: ${error}`);
+        }
+    });
+    return true;
+};

package/server/promise/triggerPromise/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: true;
+export default _default;

package/server/promise/triggerPromise/index.js

@@ -0,0 +1 @@
+export default true;