@rstest/core 0.6.0 → 0.6.2

package/dist/808.js

@@ -0,0 +1,167 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import { fileURLToPath, pathToFileURL } from "node:url";
+import node_v8 from "node:v8";
+const TYPE_REQUEST = "q";
+const TYPE_RESPONSE = "s";
+const DEFAULT_TIMEOUT = 6e4;
+function defaultSerialize(i) {
+    return i;
+}
+const defaultDeserialize = defaultSerialize;
+const { clearTimeout: dist_clearTimeout, setTimeout: dist_setTimeout } = globalThis;
+const random = Math.random.bind(Math);
+function createBirpc(functions, options) {
+    const { post, on, off = ()=>{}, eventNames = [], serialize = defaultSerialize, deserialize = defaultDeserialize, resolver, bind = "rpc", timeout = DEFAULT_TIMEOUT } = options;
+    const rpcPromiseMap = /* @__PURE__ */ new Map();
+    let _promise;
+    let closed = false;
+    const rpc = new Proxy({}, {
+        get (_, method) {
+            if ("$functions" === method) return functions;
+            if ("$close" === method) return close;
+            if ("$rejectPendingCalls" === method) return rejectPendingCalls;
+            if ("$closed" === method) return closed;
+            if ("then" === method && !eventNames.includes("then") && !("then" in functions)) return;
+            const sendEvent = (...args)=>{
+                post(serialize({
+                    m: method,
+                    a: args,
+                    t: TYPE_REQUEST
+                }));
+            };
+            if (eventNames.includes(method)) {
+                sendEvent.asEvent = sendEvent;
+                return sendEvent;
+            }
+            const sendCall = async (...args)=>{
+                if (closed) throw new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+                if (_promise) try {
+                    await _promise;
+                } finally{
+                    _promise = void 0;
+                }
+                return new Promise((resolve, reject)=>{
+                    const id = nanoid();
+                    let timeoutId;
+                    if (timeout >= 0) {
+                        timeoutId = dist_setTimeout(()=>{
+                            try {
+                                const handleResult = options.onTimeoutError?.(method, args);
+                                if (true !== handleResult) throw new Error(`[birpc] timeout on calling "${method}"`);
+                            } catch (e) {
+                                reject(e);
+                            }
+                            rpcPromiseMap.delete(id);
+                        }, timeout);
+                        if ("object" == typeof timeoutId) timeoutId = timeoutId.unref?.();
+                    }
+                    rpcPromiseMap.set(id, {
+                        resolve,
+                        reject,
+                        timeoutId,
+                        method
+                    });
+                    post(serialize({
+                        m: method,
+                        a: args,
+                        i: id,
+                        t: "q"
+                    }));
+                });
+            };
+            sendCall.asEvent = sendEvent;
+            return sendCall;
+        }
+    });
+    function close(customError) {
+        closed = true;
+        rpcPromiseMap.forEach(({ reject, method })=>{
+            const error = new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+            if (customError) {
+                customError.cause ??= error;
+                return reject(customError);
+            }
+            reject(error);
+        });
+        rpcPromiseMap.clear();
+        off(onMessage);
+    }
+    function rejectPendingCalls(handler) {
+        const entries = Array.from(rpcPromiseMap.values());
+        const handlerResults = entries.map(({ method, reject })=>{
+            if (!handler) return reject(new Error(`[birpc]: rejected pending call "${method}".`));
+            return handler({
+                method,
+                reject
+            });
+        });
+        rpcPromiseMap.clear();
+        return handlerResults;
+    }
+    async function onMessage(data, ...extra) {
+        let msg;
+        try {
+            msg = deserialize(data);
+        } catch (e) {
+            if (options.onGeneralError?.(e) !== true) throw e;
+            return;
+        }
+        if (msg.t === TYPE_REQUEST) {
+            const { m: method, a: args } = msg;
+            let result, error;
+            const fn = await (resolver ? resolver(method, functions[method]) : functions[method]);
+            if (fn) try {
+                result = await fn.apply("rpc" === bind ? rpc : functions, args);
+            } catch (e) {
+                error = e;
+            }
+            else error = new Error(`[birpc] function "${method}" not found`);
+            if (msg.i) {
+                if (error && options.onError) options.onError(error, method, args);
+                if (error && options.onFunctionError) {
+                    if (true === options.onFunctionError(error, method, args)) return;
+                }
+                if (!error) try {
+                    post(serialize({
+                        t: TYPE_RESPONSE,
+                        i: msg.i,
+                        r: result
+                    }), ...extra);
+                    return;
+                } catch (e) {
+                    error = e;
+                    if (options.onGeneralError?.(e, method, args) !== true) throw e;
+                }
+                try {
+                    post(serialize({
+                        t: TYPE_RESPONSE,
+                        i: msg.i,
+                        e: error
+                    }), ...extra);
+                } catch (e) {
+                    if (options.onGeneralError?.(e, method, args) !== true) throw e;
+                }
+            }
+        } else {
+            const { i: ack, r: result, e: error } = msg;
+            const promise = rpcPromiseMap.get(ack);
+            if (promise) {
+                dist_clearTimeout(promise.timeoutId);
+                if (error) promise.reject(error);
+                else promise.resolve(result);
+            }
+            rpcPromiseMap.delete(ack);
+        }
+    }
+    _promise = on(onMessage);
+    return rpc;
+}
+const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+function nanoid(size = 21) {
+    let id = "";
+    let i = size;
+    while(i--)id += urlAlphabet[64 * random() | 0];
+    return id;
+}
+export { createBirpc, fileURLToPath, node_v8, pathToFileURL };