added gitignore & removed node_modules
This commit is contained in:
292
node_modules/birpc/dist/index.cjs
generated
vendored
292
node_modules/birpc/dist/index.cjs
generated
vendored
@@ -1,292 +0,0 @@
|
||||
'use strict';
|
||||
|
||||
const TYPE_REQUEST = "q";
|
||||
const TYPE_RESPONSE = "s";
|
||||
const DEFAULT_TIMEOUT = 6e4;
|
||||
function defaultSerialize(i) {
|
||||
return i;
|
||||
}
|
||||
const defaultDeserialize = defaultSerialize;
|
||||
const { clearTimeout, 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;
|
||||
let $closed = false;
|
||||
const _rpcPromiseMap = /* @__PURE__ */ new Map();
|
||||
let _promiseInit;
|
||||
async function _call(method, args, event, optional) {
|
||||
if ($closed)
|
||||
throw new Error(`[birpc] rpc is closed, cannot call "${method}"`);
|
||||
const req = { m: method, a: args, t: TYPE_REQUEST };
|
||||
if (optional)
|
||||
req.o = true;
|
||||
const send = async (_req) => post(serialize(_req));
|
||||
if (event) {
|
||||
await send(req);
|
||||
return;
|
||||
}
|
||||
if (_promiseInit) {
|
||||
try {
|
||||
await _promiseInit;
|
||||
} finally {
|
||||
_promiseInit = void 0;
|
||||
}
|
||||
}
|
||||
let { promise, resolve, reject } = createPromiseWithResolvers();
|
||||
const id = nanoid();
|
||||
req.i = id;
|
||||
let timeoutId;
|
||||
async function handler(newReq = req) {
|
||||
if (timeout >= 0) {
|
||||
timeoutId = setTimeout(() => {
|
||||
try {
|
||||
const handleResult = options.onTimeoutError?.(method, args);
|
||||
if (handleResult !== true)
|
||||
throw new Error(`[birpc] timeout on calling "${method}"`);
|
||||
} catch (e) {
|
||||
reject(e);
|
||||
}
|
||||
_rpcPromiseMap.delete(id);
|
||||
}, timeout);
|
||||
if (typeof timeoutId === "object")
|
||||
timeoutId = timeoutId.unref?.();
|
||||
}
|
||||
_rpcPromiseMap.set(id, { resolve, reject, timeoutId, method });
|
||||
await send(newReq);
|
||||
return promise;
|
||||
}
|
||||
try {
|
||||
if (options.onRequest)
|
||||
await options.onRequest(req, handler, resolve);
|
||||
else
|
||||
await handler();
|
||||
} catch (e) {
|
||||
if (options.onGeneralError?.(e) !== true)
|
||||
throw e;
|
||||
return;
|
||||
} finally {
|
||||
clearTimeout(timeoutId);
|
||||
_rpcPromiseMap.delete(id);
|
||||
}
|
||||
return promise;
|
||||
}
|
||||
const $call = (method, ...args) => _call(method, args, false);
|
||||
const $callOptional = (method, ...args) => _call(method, args, false, true);
|
||||
const $callEvent = (method, ...args) => _call(method, args, true);
|
||||
const $callRaw = (options2) => _call(options2.method, options2.args, options2.event, options2.optional);
|
||||
const builtinMethods = {
|
||||
$call,
|
||||
$callOptional,
|
||||
$callEvent,
|
||||
$callRaw,
|
||||
$rejectPendingCalls,
|
||||
get $closed() {
|
||||
return $closed;
|
||||
},
|
||||
$close,
|
||||
$functions
|
||||
};
|
||||
const rpc = new Proxy({}, {
|
||||
get(_, method) {
|
||||
if (Object.prototype.hasOwnProperty.call(builtinMethods, method))
|
||||
return builtinMethods[method];
|
||||
if (method === "then" && !eventNames.includes("then") && !("then" in $functions))
|
||||
return void 0;
|
||||
const sendEvent = (...args) => _call(method, args, true);
|
||||
if (eventNames.includes(method)) {
|
||||
sendEvent.asEvent = sendEvent;
|
||||
return sendEvent;
|
||||
}
|
||||
const sendCall = (...args) => _call(method, args, false);
|
||||
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, o: optional } = msg;
|
||||
let result, error;
|
||||
let fn = await (resolver ? resolver(method, $functions[method]) : $functions[method]);
|
||||
if (optional)
|
||||
fn ||= () => void 0;
|
||||
if (!fn) {
|
||||
error = new Error(`[birpc] function "${method}" not found`);
|
||||
} else {
|
||||
try {
|
||||
result = await fn.apply(bind === "rpc" ? rpc : $functions, args);
|
||||
} catch (e) {
|
||||
error = e;
|
||||
}
|
||||
}
|
||||
if (msg.i) {
|
||||
if (error && options.onError)
|
||||
options.onError(error, method, args);
|
||||
if (error && options.onFunctionError) {
|
||||
if (options.onFunctionError(error, method, args) === true)
|
||||
return;
|
||||
}
|
||||
if (!error) {
|
||||
try {
|
||||
await 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 {
|
||||
await 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) {
|
||||
clearTimeout(promise.timeoutId);
|
||||
if (error)
|
||||
promise.reject(error);
|
||||
else
|
||||
promise.resolve(result);
|
||||
}
|
||||
_rpcPromiseMap.delete(ack);
|
||||
}
|
||||
}
|
||||
_promiseInit = on(onMessage);
|
||||
return rpc;
|
||||
}
|
||||
const cacheMap = /* @__PURE__ */ new WeakMap();
|
||||
function cachedMap(items, fn) {
|
||||
return items.map((i) => {
|
||||
let r = cacheMap.get(i);
|
||||
if (!r) {
|
||||
r = fn(i);
|
||||
cacheMap.set(i, r);
|
||||
}
|
||||
return r;
|
||||
});
|
||||
}
|
||||
function createBirpcGroup(functions, channels, options = {}) {
|
||||
const getChannels = () => typeof channels === "function" ? channels() : channels;
|
||||
const getClients = (channels2 = getChannels()) => cachedMap(channels2, (s) => createBirpc(functions, { ...options, ...s }));
|
||||
function _boardcast(method, args, event, optional) {
|
||||
const clients = getClients();
|
||||
return Promise.all(clients.map((c) => c.$callRaw({ method, args, event, optional })));
|
||||
}
|
||||
function $call(method, ...args) {
|
||||
return _boardcast(method, args, false);
|
||||
}
|
||||
function $callOptional(method, ...args) {
|
||||
return _boardcast(method, args, false, true);
|
||||
}
|
||||
function $callEvent(method, ...args) {
|
||||
return _boardcast(method, args, true);
|
||||
}
|
||||
const broadcastBuiltin = {
|
||||
$call,
|
||||
$callOptional,
|
||||
$callEvent
|
||||
};
|
||||
const broadcastProxy = new Proxy({}, {
|
||||
get(_, method) {
|
||||
if (Object.prototype.hasOwnProperty.call(broadcastBuiltin, method))
|
||||
return broadcastBuiltin[method];
|
||||
const client = getClients();
|
||||
const callbacks = client.map((c) => c[method]);
|
||||
const sendCall = (...args) => {
|
||||
return Promise.all(callbacks.map((i) => i(...args)));
|
||||
};
|
||||
sendCall.asEvent = async (...args) => {
|
||||
await Promise.all(callbacks.map((i) => i.asEvent(...args)));
|
||||
};
|
||||
return sendCall;
|
||||
}
|
||||
});
|
||||
function updateChannels(fn) {
|
||||
const channels2 = getChannels();
|
||||
fn?.(channels2);
|
||||
return getClients(channels2);
|
||||
}
|
||||
getClients();
|
||||
return {
|
||||
get clients() {
|
||||
return getClients();
|
||||
},
|
||||
functions,
|
||||
updateChannels,
|
||||
broadcast: broadcastProxy,
|
||||
/**
|
||||
* @deprecated use `broadcast`
|
||||
*/
|
||||
// @ts-expect-error deprecated
|
||||
boardcast: broadcastProxy
|
||||
};
|
||||
}
|
||||
function createPromiseWithResolvers() {
|
||||
let resolve;
|
||||
let reject;
|
||||
const promise = new Promise((res, rej) => {
|
||||
resolve = res;
|
||||
reject = rej;
|
||||
});
|
||||
return { promise, resolve, reject };
|
||||
}
|
||||
const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
|
||||
function nanoid(size = 21) {
|
||||
let id = "";
|
||||
let i = size;
|
||||
while (i--)
|
||||
id += urlAlphabet[random() * 64 | 0];
|
||||
return id;
|
||||
}
|
||||
|
||||
exports.DEFAULT_TIMEOUT = DEFAULT_TIMEOUT;
|
||||
exports.cachedMap = cachedMap;
|
||||
exports.createBirpc = createBirpc;
|
||||
exports.createBirpcGroup = createBirpcGroup;
|
||||
206
node_modules/birpc/dist/index.d.cts
generated
vendored
206
node_modules/birpc/dist/index.d.cts
generated
vendored
@@ -1,206 +0,0 @@
|
||||
type ArgumentsType<T> = T extends (...args: infer A) => any ? A : never;
|
||||
type ReturnType<T> = T extends (...args: any) => infer R ? R : never;
|
||||
type PromisifyFn<T> = ReturnType<T> extends Promise<any> ? T : (...args: ArgumentsType<T>) => Promise<Awaited<ReturnType<T>>>;
|
||||
type Thenable<T> = T | PromiseLike<T>;
|
||||
type BirpcResolver = (name: string, resolved: (...args: unknown[]) => unknown) => Thenable<((...args: unknown[]) => unknown) | undefined>;
|
||||
interface ChannelOptions {
|
||||
/**
|
||||
* Function to post raw message
|
||||
*/
|
||||
post: (data: any, ...extras: any[]) => any | Promise<any>;
|
||||
/**
|
||||
* Listener to receive raw message
|
||||
*/
|
||||
on: (fn: (data: any, ...extras: any[]) => void) => any | Promise<any>;
|
||||
/**
|
||||
* Clear the listener when `$close` is called
|
||||
*/
|
||||
off?: (fn: (data: any, ...extras: any[]) => void) => any | Promise<any>;
|
||||
/**
|
||||
* Custom function to serialize data
|
||||
*
|
||||
* by default it passes the data as-is
|
||||
*/
|
||||
serialize?: (data: any) => any;
|
||||
/**
|
||||
* Custom function to deserialize data
|
||||
*
|
||||
* by default it passes the data as-is
|
||||
*/
|
||||
deserialize?: (data: any) => any;
|
||||
/**
|
||||
* Call the methods with the RPC context or the original functions object
|
||||
*/
|
||||
bind?: 'rpc' | 'functions';
|
||||
}
|
||||
interface EventOptions<Remote> {
|
||||
/**
|
||||
* Names of remote functions that do not need response.
|
||||
*/
|
||||
eventNames?: (keyof Remote)[];
|
||||
/**
|
||||
* Maximum timeout for waiting for response, in milliseconds.
|
||||
*
|
||||
* @default 60_000
|
||||
*/
|
||||
timeout?: number;
|
||||
/**
|
||||
* Custom resolver to resolve function to be called
|
||||
*
|
||||
* For advanced use cases only
|
||||
*/
|
||||
resolver?: BirpcResolver;
|
||||
/**
|
||||
* Hook triggered before an event is sent to the remote
|
||||
*
|
||||
* @param req - Request parameters
|
||||
* @param next - Function to continue the request
|
||||
* @param resolve - Function to resolve the response directly
|
||||
*/
|
||||
onRequest?: (req: Request, next: (req?: Request) => Promise<any>, resolve: (res: any) => void) => void | Promise<void>;
|
||||
/**
|
||||
* Custom error handler
|
||||
*
|
||||
* @deprecated use `onFunctionError` and `onGeneralError` instead
|
||||
*/
|
||||
onError?: (error: Error, functionName: string, args: any[]) => boolean | void;
|
||||
/**
|
||||
* Custom error handler for errors occurred in local functions being called
|
||||
*
|
||||
* @returns `true` to prevent the error from being thrown
|
||||
*/
|
||||
onFunctionError?: (error: Error, functionName: string, args: any[]) => boolean | void;
|
||||
/**
|
||||
* Custom error handler for errors occurred during serialization or messsaging
|
||||
*
|
||||
* @returns `true` to prevent the error from being thrown
|
||||
*/
|
||||
onGeneralError?: (error: Error, functionName?: string, args?: any[]) => boolean | void;
|
||||
/**
|
||||
* Custom error handler for timeouts
|
||||
*
|
||||
* @returns `true` to prevent the error from being thrown
|
||||
*/
|
||||
onTimeoutError?: (functionName: string, args: any[]) => boolean | void;
|
||||
}
|
||||
type BirpcOptions<Remote> = EventOptions<Remote> & ChannelOptions;
|
||||
type BirpcFn<T> = PromisifyFn<T> & {
|
||||
/**
|
||||
* Send event without asking for response
|
||||
*/
|
||||
asEvent: (...args: ArgumentsType<T>) => Promise<void>;
|
||||
};
|
||||
interface BirpcGroupFn<T> {
|
||||
/**
|
||||
* Call the remote function and wait for the result.
|
||||
*/
|
||||
(...args: ArgumentsType<T>): Promise<Awaited<ReturnType<T>>[]>;
|
||||
/**
|
||||
* Send event without asking for response
|
||||
*/
|
||||
asEvent: (...args: ArgumentsType<T>) => Promise<void>;
|
||||
}
|
||||
interface BirpcReturnBuiltin<RemoteFunctions, LocalFunctions = Record<string, never>> {
|
||||
/**
|
||||
* Raw functions object
|
||||
*/
|
||||
$functions: LocalFunctions;
|
||||
/**
|
||||
* Whether the RPC is closed
|
||||
*/
|
||||
readonly $closed: boolean;
|
||||
/**
|
||||
* Close the RPC connection
|
||||
*/
|
||||
$close: (error?: Error) => void;
|
||||
/**
|
||||
* Reject pending calls
|
||||
*/
|
||||
$rejectPendingCalls: (handler?: PendingCallHandler) => Promise<void>[];
|
||||
/**
|
||||
* Call the remote function and wait for the result.
|
||||
* An alternative to directly calling the function
|
||||
*/
|
||||
$call: <K extends keyof RemoteFunctions>(method: K, ...args: ArgumentsType<RemoteFunctions[K]>) => Promise<Awaited<ReturnType<RemoteFunctions[K]>>>;
|
||||
/**
|
||||
* Same as `$call`, but returns `undefined` if the function is not defined on the remote side.
|
||||
*/
|
||||
$callOptional: <K extends keyof RemoteFunctions>(method: K, ...args: ArgumentsType<RemoteFunctions[K]>) => Promise<Awaited<ReturnType<RemoteFunctions[K]> | undefined>>;
|
||||
/**
|
||||
* Send event without asking for response
|
||||
*/
|
||||
$callEvent: <K extends keyof RemoteFunctions>(method: K, ...args: ArgumentsType<RemoteFunctions[K]>) => Promise<void>;
|
||||
/**
|
||||
* Call the remote function with the raw options.
|
||||
*/
|
||||
$callRaw: (options: {
|
||||
method: string;
|
||||
args: unknown[];
|
||||
event?: boolean;
|
||||
optional?: boolean;
|
||||
}) => Promise<Awaited<ReturnType<any>>[]>;
|
||||
}
|
||||
type BirpcReturn<RemoteFunctions, LocalFunctions = Record<string, never>> = {
|
||||
[K in keyof RemoteFunctions]: BirpcFn<RemoteFunctions[K]>;
|
||||
} & BirpcReturnBuiltin<RemoteFunctions, LocalFunctions>;
|
||||
type PendingCallHandler = (options: Pick<PromiseEntry, 'method' | 'reject'>) => void | Promise<void>;
|
||||
interface BirpcGroupReturnBuiltin<RemoteFunctions> {
|
||||
/**
|
||||
* Call the remote function and wait for the result.
|
||||
* An alternative to directly calling the function
|
||||
*/
|
||||
$call: <K extends keyof RemoteFunctions>(method: K, ...args: ArgumentsType<RemoteFunctions[K]>) => Promise<Awaited<ReturnType<RemoteFunctions[K]>>>;
|
||||
/**
|
||||
* Same as `$call`, but returns `undefined` if the function is not defined on the remote side.
|
||||
*/
|
||||
$callOptional: <K extends keyof RemoteFunctions>(method: K, ...args: ArgumentsType<RemoteFunctions[K]>) => Promise<Awaited<ReturnType<RemoteFunctions[K]> | undefined>>;
|
||||
/**
|
||||
* Send event without asking for response
|
||||
*/
|
||||
$callEvent: <K extends keyof RemoteFunctions>(method: K, ...args: ArgumentsType<RemoteFunctions[K]>) => Promise<void>;
|
||||
}
|
||||
type BirpcGroupReturn<RemoteFunctions> = {
|
||||
[K in keyof RemoteFunctions]: BirpcGroupFn<RemoteFunctions[K]>;
|
||||
} & BirpcGroupReturnBuiltin<RemoteFunctions>;
|
||||
interface BirpcGroup<RemoteFunctions, LocalFunctions = Record<string, never>> {
|
||||
readonly clients: BirpcReturn<RemoteFunctions, LocalFunctions>[];
|
||||
readonly functions: LocalFunctions;
|
||||
readonly broadcast: BirpcGroupReturn<RemoteFunctions>;
|
||||
updateChannels: (fn?: ((channels: ChannelOptions[]) => void)) => BirpcReturn<RemoteFunctions, LocalFunctions>[];
|
||||
}
|
||||
interface PromiseEntry {
|
||||
resolve: (arg: any) => void;
|
||||
reject: (error: any) => void;
|
||||
method: string;
|
||||
timeoutId?: ReturnType<typeof setTimeout>;
|
||||
}
|
||||
declare const TYPE_REQUEST: "q";
|
||||
interface Request {
|
||||
/**
|
||||
* Type
|
||||
*/
|
||||
t: typeof TYPE_REQUEST;
|
||||
/**
|
||||
* ID
|
||||
*/
|
||||
i?: string;
|
||||
/**
|
||||
* Method
|
||||
*/
|
||||
m: string;
|
||||
/**
|
||||
* Arguments
|
||||
*/
|
||||
a: any[];
|
||||
/**
|
||||
* Optional
|
||||
*/
|
||||
o?: boolean;
|
||||
}
|
||||
declare const DEFAULT_TIMEOUT = 60000;
|
||||
declare const setTimeout: typeof globalThis.setTimeout;
|
||||
declare function createBirpc<RemoteFunctions = Record<string, never>, LocalFunctions extends object = Record<string, never>>($functions: LocalFunctions, options: BirpcOptions<RemoteFunctions>): BirpcReturn<RemoteFunctions, LocalFunctions>;
|
||||
declare function cachedMap<T, R>(items: T[], fn: ((i: T) => R)): R[];
|
||||
declare function createBirpcGroup<RemoteFunctions = Record<string, never>, LocalFunctions extends object = Record<string, never>>(functions: LocalFunctions, channels: ChannelOptions[] | (() => ChannelOptions[]), options?: EventOptions<RemoteFunctions>): BirpcGroup<RemoteFunctions, LocalFunctions>;
|
||||
|
||||
export { type ArgumentsType, type BirpcFn, type BirpcGroup, type BirpcGroupFn, type BirpcGroupReturn, type BirpcGroupReturnBuiltin, type BirpcOptions, type BirpcResolver, type BirpcReturn, type BirpcReturnBuiltin, type ChannelOptions, DEFAULT_TIMEOUT, type EventOptions, type PromisifyFn, type ReturnType, type Thenable, cachedMap, createBirpc, createBirpcGroup };
|
||||
206
node_modules/birpc/dist/index.d.mts
generated
vendored
206
node_modules/birpc/dist/index.d.mts
generated
vendored
@@ -1,206 +0,0 @@
|
||||
type ArgumentsType<T> = T extends (...args: infer A) => any ? A : never;
|
||||
type ReturnType<T> = T extends (...args: any) => infer R ? R : never;
|
||||
type PromisifyFn<T> = ReturnType<T> extends Promise<any> ? T : (...args: ArgumentsType<T>) => Promise<Awaited<ReturnType<T>>>;
|
||||
type Thenable<T> = T | PromiseLike<T>;
|
||||
type BirpcResolver = (name: string, resolved: (...args: unknown[]) => unknown) => Thenable<((...args: unknown[]) => unknown) | undefined>;
|
||||
interface ChannelOptions {
|
||||
/**
|
||||
* Function to post raw message
|
||||
*/
|
||||
post: (data: any, ...extras: any[]) => any | Promise<any>;
|
||||
/**
|
||||
* Listener to receive raw message
|
||||
*/
|
||||
on: (fn: (data: any, ...extras: any[]) => void) => any | Promise<any>;
|
||||
/**
|
||||
* Clear the listener when `$close` is called
|
||||
*/
|
||||
off?: (fn: (data: any, ...extras: any[]) => void) => any | Promise<any>;
|
||||
/**
|
||||
* Custom function to serialize data
|
||||
*
|
||||
* by default it passes the data as-is
|
||||
*/
|
||||
serialize?: (data: any) => any;
|
||||
/**
|
||||
* Custom function to deserialize data
|
||||
*
|
||||
* by default it passes the data as-is
|
||||
*/
|
||||
deserialize?: (data: any) => any;
|
||||
/**
|
||||
* Call the methods with the RPC context or the original functions object
|
||||
*/
|
||||
bind?: 'rpc' | 'functions';
|
||||
}
|
||||
interface EventOptions<Remote> {
|
||||
/**
|
||||
* Names of remote functions that do not need response.
|
||||
*/
|
||||
eventNames?: (keyof Remote)[];
|
||||
/**
|
||||
* Maximum timeout for waiting for response, in milliseconds.
|
||||
*
|
||||
* @default 60_000
|
||||
*/
|
||||
timeout?: number;
|
||||
/**
|
||||
* Custom resolver to resolve function to be called
|
||||
*
|
||||
* For advanced use cases only
|
||||
*/
|
||||
resolver?: BirpcResolver;
|
||||
/**
|
||||
* Hook triggered before an event is sent to the remote
|
||||
*
|
||||
* @param req - Request parameters
|
||||
* @param next - Function to continue the request
|
||||
* @param resolve - Function to resolve the response directly
|
||||
*/
|
||||
onRequest?: (req: Request, next: (req?: Request) => Promise<any>, resolve: (res: any) => void) => void | Promise<void>;
|
||||
/**
|
||||
* Custom error handler
|
||||
*
|
||||
* @deprecated use `onFunctionError` and `onGeneralError` instead
|
||||
*/
|
||||
onError?: (error: Error, functionName: string, args: any[]) => boolean | void;
|
||||
/**
|
||||
* Custom error handler for errors occurred in local functions being called
|
||||
*
|
||||
* @returns `true` to prevent the error from being thrown
|
||||
*/
|
||||
onFunctionError?: (error: Error, functionName: string, args: any[]) => boolean | void;
|
||||
/**
|
||||
* Custom error handler for errors occurred during serialization or messsaging
|
||||
*
|
||||
* @returns `true` to prevent the error from being thrown
|
||||
*/
|
||||
onGeneralError?: (error: Error, functionName?: string, args?: any[]) => boolean | void;
|
||||
/**
|
||||
* Custom error handler for timeouts
|
||||
*
|
||||
* @returns `true` to prevent the error from being thrown
|
||||
*/
|
||||
onTimeoutError?: (functionName: string, args: any[]) => boolean | void;
|
||||
}
|
||||
type BirpcOptions<Remote> = EventOptions<Remote> & ChannelOptions;
|
||||
type BirpcFn<T> = PromisifyFn<T> & {
|
||||
/**
|
||||
* Send event without asking for response
|
||||
*/
|
||||
asEvent: (...args: ArgumentsType<T>) => Promise<void>;
|
||||
};
|
||||
interface BirpcGroupFn<T> {
|
||||
/**
|
||||
* Call the remote function and wait for the result.
|
||||
*/
|
||||
(...args: ArgumentsType<T>): Promise<Awaited<ReturnType<T>>[]>;
|
||||
/**
|
||||
* Send event without asking for response
|
||||
*/
|
||||
asEvent: (...args: ArgumentsType<T>) => Promise<void>;
|
||||
}
|
||||
interface BirpcReturnBuiltin<RemoteFunctions, LocalFunctions = Record<string, never>> {
|
||||
/**
|
||||
* Raw functions object
|
||||
*/
|
||||
$functions: LocalFunctions;
|
||||
/**
|
||||
* Whether the RPC is closed
|
||||
*/
|
||||
readonly $closed: boolean;
|
||||
/**
|
||||
* Close the RPC connection
|
||||
*/
|
||||
$close: (error?: Error) => void;
|
||||
/**
|
||||
* Reject pending calls
|
||||
*/
|
||||
$rejectPendingCalls: (handler?: PendingCallHandler) => Promise<void>[];
|
||||
/**
|
||||
* Call the remote function and wait for the result.
|
||||
* An alternative to directly calling the function
|
||||
*/
|
||||
$call: <K extends keyof RemoteFunctions>(method: K, ...args: ArgumentsType<RemoteFunctions[K]>) => Promise<Awaited<ReturnType<RemoteFunctions[K]>>>;
|
||||
/**
|
||||
* Same as `$call`, but returns `undefined` if the function is not defined on the remote side.
|
||||
*/
|
||||
$callOptional: <K extends keyof RemoteFunctions>(method: K, ...args: ArgumentsType<RemoteFunctions[K]>) => Promise<Awaited<ReturnType<RemoteFunctions[K]> | undefined>>;
|
||||
/**
|
||||
* Send event without asking for response
|
||||
*/
|
||||
$callEvent: <K extends keyof RemoteFunctions>(method: K, ...args: ArgumentsType<RemoteFunctions[K]>) => Promise<void>;
|
||||
/**
|
||||
* Call the remote function with the raw options.
|
||||
*/
|
||||
$callRaw: (options: {
|
||||
method: string;
|
||||
args: unknown[];
|
||||
event?: boolean;
|
||||
optional?: boolean;
|
||||
}) => Promise<Awaited<ReturnType<any>>[]>;
|
||||
}
|
||||
type BirpcReturn<RemoteFunctions, LocalFunctions = Record<string, never>> = {
|
||||
[K in keyof RemoteFunctions]: BirpcFn<RemoteFunctions[K]>;
|
||||
} & BirpcReturnBuiltin<RemoteFunctions, LocalFunctions>;
|
||||
type PendingCallHandler = (options: Pick<PromiseEntry, 'method' | 'reject'>) => void | Promise<void>;
|
||||
interface BirpcGroupReturnBuiltin<RemoteFunctions> {
|
||||
/**
|
||||
* Call the remote function and wait for the result.
|
||||
* An alternative to directly calling the function
|
||||
*/
|
||||
$call: <K extends keyof RemoteFunctions>(method: K, ...args: ArgumentsType<RemoteFunctions[K]>) => Promise<Awaited<ReturnType<RemoteFunctions[K]>>>;
|
||||
/**
|
||||
* Same as `$call`, but returns `undefined` if the function is not defined on the remote side.
|
||||
*/
|
||||
$callOptional: <K extends keyof RemoteFunctions>(method: K, ...args: ArgumentsType<RemoteFunctions[K]>) => Promise<Awaited<ReturnType<RemoteFunctions[K]> | undefined>>;
|
||||
/**
|
||||
* Send event without asking for response
|
||||
*/
|
||||
$callEvent: <K extends keyof RemoteFunctions>(method: K, ...args: ArgumentsType<RemoteFunctions[K]>) => Promise<void>;
|
||||
}
|
||||
type BirpcGroupReturn<RemoteFunctions> = {
|
||||
[K in keyof RemoteFunctions]: BirpcGroupFn<RemoteFunctions[K]>;
|
||||
} & BirpcGroupReturnBuiltin<RemoteFunctions>;
|
||||
interface BirpcGroup<RemoteFunctions, LocalFunctions = Record<string, never>> {
|
||||
readonly clients: BirpcReturn<RemoteFunctions, LocalFunctions>[];
|
||||
readonly functions: LocalFunctions;
|
||||
readonly broadcast: BirpcGroupReturn<RemoteFunctions>;
|
||||
updateChannels: (fn?: ((channels: ChannelOptions[]) => void)) => BirpcReturn<RemoteFunctions, LocalFunctions>[];
|
||||
}
|
||||
interface PromiseEntry {
|
||||
resolve: (arg: any) => void;
|
||||
reject: (error: any) => void;
|
||||
method: string;
|
||||
timeoutId?: ReturnType<typeof setTimeout>;
|
||||
}
|
||||
declare const TYPE_REQUEST: "q";
|
||||
interface Request {
|
||||
/**
|
||||
* Type
|
||||
*/
|
||||
t: typeof TYPE_REQUEST;
|
||||
/**
|
||||
* ID
|
||||
*/
|
||||
i?: string;
|
||||
/**
|
||||
* Method
|
||||
*/
|
||||
m: string;
|
||||
/**
|
||||
* Arguments
|
||||
*/
|
||||
a: any[];
|
||||
/**
|
||||
* Optional
|
||||
*/
|
||||
o?: boolean;
|
||||
}
|
||||
declare const DEFAULT_TIMEOUT = 60000;
|
||||
declare const setTimeout: typeof globalThis.setTimeout;
|
||||
declare function createBirpc<RemoteFunctions = Record<string, never>, LocalFunctions extends object = Record<string, never>>($functions: LocalFunctions, options: BirpcOptions<RemoteFunctions>): BirpcReturn<RemoteFunctions, LocalFunctions>;
|
||||
declare function cachedMap<T, R>(items: T[], fn: ((i: T) => R)): R[];
|
||||
declare function createBirpcGroup<RemoteFunctions = Record<string, never>, LocalFunctions extends object = Record<string, never>>(functions: LocalFunctions, channels: ChannelOptions[] | (() => ChannelOptions[]), options?: EventOptions<RemoteFunctions>): BirpcGroup<RemoteFunctions, LocalFunctions>;
|
||||
|
||||
export { type ArgumentsType, type BirpcFn, type BirpcGroup, type BirpcGroupFn, type BirpcGroupReturn, type BirpcGroupReturnBuiltin, type BirpcOptions, type BirpcResolver, type BirpcReturn, type BirpcReturnBuiltin, type ChannelOptions, DEFAULT_TIMEOUT, type EventOptions, type PromisifyFn, type ReturnType, type Thenable, cachedMap, createBirpc, createBirpcGroup };
|
||||
206
node_modules/birpc/dist/index.d.ts
generated
vendored
206
node_modules/birpc/dist/index.d.ts
generated
vendored
@@ -1,206 +0,0 @@
|
||||
type ArgumentsType<T> = T extends (...args: infer A) => any ? A : never;
|
||||
type ReturnType<T> = T extends (...args: any) => infer R ? R : never;
|
||||
type PromisifyFn<T> = ReturnType<T> extends Promise<any> ? T : (...args: ArgumentsType<T>) => Promise<Awaited<ReturnType<T>>>;
|
||||
type Thenable<T> = T | PromiseLike<T>;
|
||||
type BirpcResolver = (name: string, resolved: (...args: unknown[]) => unknown) => Thenable<((...args: unknown[]) => unknown) | undefined>;
|
||||
interface ChannelOptions {
|
||||
/**
|
||||
* Function to post raw message
|
||||
*/
|
||||
post: (data: any, ...extras: any[]) => any | Promise<any>;
|
||||
/**
|
||||
* Listener to receive raw message
|
||||
*/
|
||||
on: (fn: (data: any, ...extras: any[]) => void) => any | Promise<any>;
|
||||
/**
|
||||
* Clear the listener when `$close` is called
|
||||
*/
|
||||
off?: (fn: (data: any, ...extras: any[]) => void) => any | Promise<any>;
|
||||
/**
|
||||
* Custom function to serialize data
|
||||
*
|
||||
* by default it passes the data as-is
|
||||
*/
|
||||
serialize?: (data: any) => any;
|
||||
/**
|
||||
* Custom function to deserialize data
|
||||
*
|
||||
* by default it passes the data as-is
|
||||
*/
|
||||
deserialize?: (data: any) => any;
|
||||
/**
|
||||
* Call the methods with the RPC context or the original functions object
|
||||
*/
|
||||
bind?: 'rpc' | 'functions';
|
||||
}
|
||||
interface EventOptions<Remote> {
|
||||
/**
|
||||
* Names of remote functions that do not need response.
|
||||
*/
|
||||
eventNames?: (keyof Remote)[];
|
||||
/**
|
||||
* Maximum timeout for waiting for response, in milliseconds.
|
||||
*
|
||||
* @default 60_000
|
||||
*/
|
||||
timeout?: number;
|
||||
/**
|
||||
* Custom resolver to resolve function to be called
|
||||
*
|
||||
* For advanced use cases only
|
||||
*/
|
||||
resolver?: BirpcResolver;
|
||||
/**
|
||||
* Hook triggered before an event is sent to the remote
|
||||
*
|
||||
* @param req - Request parameters
|
||||
* @param next - Function to continue the request
|
||||
* @param resolve - Function to resolve the response directly
|
||||
*/
|
||||
onRequest?: (req: Request, next: (req?: Request) => Promise<any>, resolve: (res: any) => void) => void | Promise<void>;
|
||||
/**
|
||||
* Custom error handler
|
||||
*
|
||||
* @deprecated use `onFunctionError` and `onGeneralError` instead
|
||||
*/
|
||||
onError?: (error: Error, functionName: string, args: any[]) => boolean | void;
|
||||
/**
|
||||
* Custom error handler for errors occurred in local functions being called
|
||||
*
|
||||
* @returns `true` to prevent the error from being thrown
|
||||
*/
|
||||
onFunctionError?: (error: Error, functionName: string, args: any[]) => boolean | void;
|
||||
/**
|
||||
* Custom error handler for errors occurred during serialization or messsaging
|
||||
*
|
||||
* @returns `true` to prevent the error from being thrown
|
||||
*/
|
||||
onGeneralError?: (error: Error, functionName?: string, args?: any[]) => boolean | void;
|
||||
/**
|
||||
* Custom error handler for timeouts
|
||||
*
|
||||
* @returns `true` to prevent the error from being thrown
|
||||
*/
|
||||
onTimeoutError?: (functionName: string, args: any[]) => boolean | void;
|
||||
}
|
||||
type BirpcOptions<Remote> = EventOptions<Remote> & ChannelOptions;
|
||||
type BirpcFn<T> = PromisifyFn<T> & {
|
||||
/**
|
||||
* Send event without asking for response
|
||||
*/
|
||||
asEvent: (...args: ArgumentsType<T>) => Promise<void>;
|
||||
};
|
||||
interface BirpcGroupFn<T> {
|
||||
/**
|
||||
* Call the remote function and wait for the result.
|
||||
*/
|
||||
(...args: ArgumentsType<T>): Promise<Awaited<ReturnType<T>>[]>;
|
||||
/**
|
||||
* Send event without asking for response
|
||||
*/
|
||||
asEvent: (...args: ArgumentsType<T>) => Promise<void>;
|
||||
}
|
||||
interface BirpcReturnBuiltin<RemoteFunctions, LocalFunctions = Record<string, never>> {
|
||||
/**
|
||||
* Raw functions object
|
||||
*/
|
||||
$functions: LocalFunctions;
|
||||
/**
|
||||
* Whether the RPC is closed
|
||||
*/
|
||||
readonly $closed: boolean;
|
||||
/**
|
||||
* Close the RPC connection
|
||||
*/
|
||||
$close: (error?: Error) => void;
|
||||
/**
|
||||
* Reject pending calls
|
||||
*/
|
||||
$rejectPendingCalls: (handler?: PendingCallHandler) => Promise<void>[];
|
||||
/**
|
||||
* Call the remote function and wait for the result.
|
||||
* An alternative to directly calling the function
|
||||
*/
|
||||
$call: <K extends keyof RemoteFunctions>(method: K, ...args: ArgumentsType<RemoteFunctions[K]>) => Promise<Awaited<ReturnType<RemoteFunctions[K]>>>;
|
||||
/**
|
||||
* Same as `$call`, but returns `undefined` if the function is not defined on the remote side.
|
||||
*/
|
||||
$callOptional: <K extends keyof RemoteFunctions>(method: K, ...args: ArgumentsType<RemoteFunctions[K]>) => Promise<Awaited<ReturnType<RemoteFunctions[K]> | undefined>>;
|
||||
/**
|
||||
* Send event without asking for response
|
||||
*/
|
||||
$callEvent: <K extends keyof RemoteFunctions>(method: K, ...args: ArgumentsType<RemoteFunctions[K]>) => Promise<void>;
|
||||
/**
|
||||
* Call the remote function with the raw options.
|
||||
*/
|
||||
$callRaw: (options: {
|
||||
method: string;
|
||||
args: unknown[];
|
||||
event?: boolean;
|
||||
optional?: boolean;
|
||||
}) => Promise<Awaited<ReturnType<any>>[]>;
|
||||
}
|
||||
type BirpcReturn<RemoteFunctions, LocalFunctions = Record<string, never>> = {
|
||||
[K in keyof RemoteFunctions]: BirpcFn<RemoteFunctions[K]>;
|
||||
} & BirpcReturnBuiltin<RemoteFunctions, LocalFunctions>;
|
||||
type PendingCallHandler = (options: Pick<PromiseEntry, 'method' | 'reject'>) => void | Promise<void>;
|
||||
interface BirpcGroupReturnBuiltin<RemoteFunctions> {
|
||||
/**
|
||||
* Call the remote function and wait for the result.
|
||||
* An alternative to directly calling the function
|
||||
*/
|
||||
$call: <K extends keyof RemoteFunctions>(method: K, ...args: ArgumentsType<RemoteFunctions[K]>) => Promise<Awaited<ReturnType<RemoteFunctions[K]>>>;
|
||||
/**
|
||||
* Same as `$call`, but returns `undefined` if the function is not defined on the remote side.
|
||||
*/
|
||||
$callOptional: <K extends keyof RemoteFunctions>(method: K, ...args: ArgumentsType<RemoteFunctions[K]>) => Promise<Awaited<ReturnType<RemoteFunctions[K]> | undefined>>;
|
||||
/**
|
||||
* Send event without asking for response
|
||||
*/
|
||||
$callEvent: <K extends keyof RemoteFunctions>(method: K, ...args: ArgumentsType<RemoteFunctions[K]>) => Promise<void>;
|
||||
}
|
||||
type BirpcGroupReturn<RemoteFunctions> = {
|
||||
[K in keyof RemoteFunctions]: BirpcGroupFn<RemoteFunctions[K]>;
|
||||
} & BirpcGroupReturnBuiltin<RemoteFunctions>;
|
||||
interface BirpcGroup<RemoteFunctions, LocalFunctions = Record<string, never>> {
|
||||
readonly clients: BirpcReturn<RemoteFunctions, LocalFunctions>[];
|
||||
readonly functions: LocalFunctions;
|
||||
readonly broadcast: BirpcGroupReturn<RemoteFunctions>;
|
||||
updateChannels: (fn?: ((channels: ChannelOptions[]) => void)) => BirpcReturn<RemoteFunctions, LocalFunctions>[];
|
||||
}
|
||||
interface PromiseEntry {
|
||||
resolve: (arg: any) => void;
|
||||
reject: (error: any) => void;
|
||||
method: string;
|
||||
timeoutId?: ReturnType<typeof setTimeout>;
|
||||
}
|
||||
declare const TYPE_REQUEST: "q";
|
||||
interface Request {
|
||||
/**
|
||||
* Type
|
||||
*/
|
||||
t: typeof TYPE_REQUEST;
|
||||
/**
|
||||
* ID
|
||||
*/
|
||||
i?: string;
|
||||
/**
|
||||
* Method
|
||||
*/
|
||||
m: string;
|
||||
/**
|
||||
* Arguments
|
||||
*/
|
||||
a: any[];
|
||||
/**
|
||||
* Optional
|
||||
*/
|
||||
o?: boolean;
|
||||
}
|
||||
declare const DEFAULT_TIMEOUT = 60000;
|
||||
declare const setTimeout: typeof globalThis.setTimeout;
|
||||
declare function createBirpc<RemoteFunctions = Record<string, never>, LocalFunctions extends object = Record<string, never>>($functions: LocalFunctions, options: BirpcOptions<RemoteFunctions>): BirpcReturn<RemoteFunctions, LocalFunctions>;
|
||||
declare function cachedMap<T, R>(items: T[], fn: ((i: T) => R)): R[];
|
||||
declare function createBirpcGroup<RemoteFunctions = Record<string, never>, LocalFunctions extends object = Record<string, never>>(functions: LocalFunctions, channels: ChannelOptions[] | (() => ChannelOptions[]), options?: EventOptions<RemoteFunctions>): BirpcGroup<RemoteFunctions, LocalFunctions>;
|
||||
|
||||
export { type ArgumentsType, type BirpcFn, type BirpcGroup, type BirpcGroupFn, type BirpcGroupReturn, type BirpcGroupReturnBuiltin, type BirpcOptions, type BirpcResolver, type BirpcReturn, type BirpcReturnBuiltin, type ChannelOptions, DEFAULT_TIMEOUT, type EventOptions, type PromisifyFn, type ReturnType, type Thenable, cachedMap, createBirpc, createBirpcGroup };
|
||||
287
node_modules/birpc/dist/index.mjs
generated
vendored
287
node_modules/birpc/dist/index.mjs
generated
vendored
@@ -1,287 +0,0 @@
|
||||
const TYPE_REQUEST = "q";
|
||||
const TYPE_RESPONSE = "s";
|
||||
const DEFAULT_TIMEOUT = 6e4;
|
||||
function defaultSerialize(i) {
|
||||
return i;
|
||||
}
|
||||
const defaultDeserialize = defaultSerialize;
|
||||
const { clearTimeout, 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;
|
||||
let $closed = false;
|
||||
const _rpcPromiseMap = /* @__PURE__ */ new Map();
|
||||
let _promiseInit;
|
||||
async function _call(method, args, event, optional) {
|
||||
if ($closed)
|
||||
throw new Error(`[birpc] rpc is closed, cannot call "${method}"`);
|
||||
const req = { m: method, a: args, t: TYPE_REQUEST };
|
||||
if (optional)
|
||||
req.o = true;
|
||||
const send = async (_req) => post(serialize(_req));
|
||||
if (event) {
|
||||
await send(req);
|
||||
return;
|
||||
}
|
||||
if (_promiseInit) {
|
||||
try {
|
||||
await _promiseInit;
|
||||
} finally {
|
||||
_promiseInit = void 0;
|
||||
}
|
||||
}
|
||||
let { promise, resolve, reject } = createPromiseWithResolvers();
|
||||
const id = nanoid();
|
||||
req.i = id;
|
||||
let timeoutId;
|
||||
async function handler(newReq = req) {
|
||||
if (timeout >= 0) {
|
||||
timeoutId = setTimeout(() => {
|
||||
try {
|
||||
const handleResult = options.onTimeoutError?.(method, args);
|
||||
if (handleResult !== true)
|
||||
throw new Error(`[birpc] timeout on calling "${method}"`);
|
||||
} catch (e) {
|
||||
reject(e);
|
||||
}
|
||||
_rpcPromiseMap.delete(id);
|
||||
}, timeout);
|
||||
if (typeof timeoutId === "object")
|
||||
timeoutId = timeoutId.unref?.();
|
||||
}
|
||||
_rpcPromiseMap.set(id, { resolve, reject, timeoutId, method });
|
||||
await send(newReq);
|
||||
return promise;
|
||||
}
|
||||
try {
|
||||
if (options.onRequest)
|
||||
await options.onRequest(req, handler, resolve);
|
||||
else
|
||||
await handler();
|
||||
} catch (e) {
|
||||
if (options.onGeneralError?.(e) !== true)
|
||||
throw e;
|
||||
return;
|
||||
} finally {
|
||||
clearTimeout(timeoutId);
|
||||
_rpcPromiseMap.delete(id);
|
||||
}
|
||||
return promise;
|
||||
}
|
||||
const $call = (method, ...args) => _call(method, args, false);
|
||||
const $callOptional = (method, ...args) => _call(method, args, false, true);
|
||||
const $callEvent = (method, ...args) => _call(method, args, true);
|
||||
const $callRaw = (options2) => _call(options2.method, options2.args, options2.event, options2.optional);
|
||||
const builtinMethods = {
|
||||
$call,
|
||||
$callOptional,
|
||||
$callEvent,
|
||||
$callRaw,
|
||||
$rejectPendingCalls,
|
||||
get $closed() {
|
||||
return $closed;
|
||||
},
|
||||
$close,
|
||||
$functions
|
||||
};
|
||||
const rpc = new Proxy({}, {
|
||||
get(_, method) {
|
||||
if (Object.prototype.hasOwnProperty.call(builtinMethods, method))
|
||||
return builtinMethods[method];
|
||||
if (method === "then" && !eventNames.includes("then") && !("then" in $functions))
|
||||
return void 0;
|
||||
const sendEvent = (...args) => _call(method, args, true);
|
||||
if (eventNames.includes(method)) {
|
||||
sendEvent.asEvent = sendEvent;
|
||||
return sendEvent;
|
||||
}
|
||||
const sendCall = (...args) => _call(method, args, false);
|
||||
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, o: optional } = msg;
|
||||
let result, error;
|
||||
let fn = await (resolver ? resolver(method, $functions[method]) : $functions[method]);
|
||||
if (optional)
|
||||
fn ||= () => void 0;
|
||||
if (!fn) {
|
||||
error = new Error(`[birpc] function "${method}" not found`);
|
||||
} else {
|
||||
try {
|
||||
result = await fn.apply(bind === "rpc" ? rpc : $functions, args);
|
||||
} catch (e) {
|
||||
error = e;
|
||||
}
|
||||
}
|
||||
if (msg.i) {
|
||||
if (error && options.onError)
|
||||
options.onError(error, method, args);
|
||||
if (error && options.onFunctionError) {
|
||||
if (options.onFunctionError(error, method, args) === true)
|
||||
return;
|
||||
}
|
||||
if (!error) {
|
||||
try {
|
||||
await 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 {
|
||||
await 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) {
|
||||
clearTimeout(promise.timeoutId);
|
||||
if (error)
|
||||
promise.reject(error);
|
||||
else
|
||||
promise.resolve(result);
|
||||
}
|
||||
_rpcPromiseMap.delete(ack);
|
||||
}
|
||||
}
|
||||
_promiseInit = on(onMessage);
|
||||
return rpc;
|
||||
}
|
||||
const cacheMap = /* @__PURE__ */ new WeakMap();
|
||||
function cachedMap(items, fn) {
|
||||
return items.map((i) => {
|
||||
let r = cacheMap.get(i);
|
||||
if (!r) {
|
||||
r = fn(i);
|
||||
cacheMap.set(i, r);
|
||||
}
|
||||
return r;
|
||||
});
|
||||
}
|
||||
function createBirpcGroup(functions, channels, options = {}) {
|
||||
const getChannels = () => typeof channels === "function" ? channels() : channels;
|
||||
const getClients = (channels2 = getChannels()) => cachedMap(channels2, (s) => createBirpc(functions, { ...options, ...s }));
|
||||
function _boardcast(method, args, event, optional) {
|
||||
const clients = getClients();
|
||||
return Promise.all(clients.map((c) => c.$callRaw({ method, args, event, optional })));
|
||||
}
|
||||
function $call(method, ...args) {
|
||||
return _boardcast(method, args, false);
|
||||
}
|
||||
function $callOptional(method, ...args) {
|
||||
return _boardcast(method, args, false, true);
|
||||
}
|
||||
function $callEvent(method, ...args) {
|
||||
return _boardcast(method, args, true);
|
||||
}
|
||||
const broadcastBuiltin = {
|
||||
$call,
|
||||
$callOptional,
|
||||
$callEvent
|
||||
};
|
||||
const broadcastProxy = new Proxy({}, {
|
||||
get(_, method) {
|
||||
if (Object.prototype.hasOwnProperty.call(broadcastBuiltin, method))
|
||||
return broadcastBuiltin[method];
|
||||
const client = getClients();
|
||||
const callbacks = client.map((c) => c[method]);
|
||||
const sendCall = (...args) => {
|
||||
return Promise.all(callbacks.map((i) => i(...args)));
|
||||
};
|
||||
sendCall.asEvent = async (...args) => {
|
||||
await Promise.all(callbacks.map((i) => i.asEvent(...args)));
|
||||
};
|
||||
return sendCall;
|
||||
}
|
||||
});
|
||||
function updateChannels(fn) {
|
||||
const channels2 = getChannels();
|
||||
fn?.(channels2);
|
||||
return getClients(channels2);
|
||||
}
|
||||
getClients();
|
||||
return {
|
||||
get clients() {
|
||||
return getClients();
|
||||
},
|
||||
functions,
|
||||
updateChannels,
|
||||
broadcast: broadcastProxy,
|
||||
/**
|
||||
* @deprecated use `broadcast`
|
||||
*/
|
||||
// @ts-expect-error deprecated
|
||||
boardcast: broadcastProxy
|
||||
};
|
||||
}
|
||||
function createPromiseWithResolvers() {
|
||||
let resolve;
|
||||
let reject;
|
||||
const promise = new Promise((res, rej) => {
|
||||
resolve = res;
|
||||
reject = rej;
|
||||
});
|
||||
return { promise, resolve, reject };
|
||||
}
|
||||
const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
|
||||
function nanoid(size = 21) {
|
||||
let id = "";
|
||||
let i = size;
|
||||
while (i--)
|
||||
id += urlAlphabet[random() * 64 | 0];
|
||||
return id;
|
||||
}
|
||||
|
||||
export { DEFAULT_TIMEOUT, cachedMap, createBirpc, createBirpcGroup };
|
||||
Reference in New Issue
Block a user