vitest 4.0.7 → 4.0.9

package/dist/chunks/console.CTJL2nuH.js

@@ -1,115 +0,0 @@
-import { Console } from 'node:console';
-import { relative } from 'node:path';
-import { Writable } from 'node:stream';
-import { getSafeTimers } from '@vitest/utils/timers';
-import c from 'tinyrainbow';
-import { R as RealDate } from './date.-jtEtIeV.js';
-import { g as getWorkerState } from './utils.CG9h5ccR.js';
-
-const UNKNOWN_TEST_ID = "__vitest__unknown_test__";
-function getTaskIdByStack(root) {
-	const stack = (/* @__PURE__ */ new Error("STACK_TRACE_ERROR")).stack?.split("\n");
-	if (!stack) return UNKNOWN_TEST_ID;
-	const index = stack.findIndex((line) => line.includes("at Console.value")), line = index === -1 ? null : stack[index + 2];
-	if (!line) return UNKNOWN_TEST_ID;
-	const filepath = line.match(/at\s(.*)\s?/)?.[1];
-	return filepath ? relative(root, filepath) : UNKNOWN_TEST_ID;
-}
-function createCustomConsole(defaultState) {
-	const stdoutBuffer = /* @__PURE__ */ new Map(), stderrBuffer = /* @__PURE__ */ new Map(), timers = /* @__PURE__ */ new Map(), { queueMicrotask } = getSafeTimers();
-	function queueCancelableMicrotask(callback) {
-		let canceled = false;
-		return queueMicrotask(() => {
-			if (!canceled) callback();
-		}), () => {
-			canceled = true;
-		};
-	}
-	const state = () => defaultState || getWorkerState();
-	// group sync console.log calls with micro task
-	function schedule(taskId) {
-		const timer = timers.get(taskId), { stdoutTime, stderrTime } = timer;
-		timer.cancel?.(), timer.cancel = queueCancelableMicrotask(() => {
-			if (stderrTime < stdoutTime) sendStderr(taskId), sendStdout(taskId);
-			else sendStdout(taskId), sendStderr(taskId);
-		});
-	}
-	function sendStdout(taskId) {
-		sendBuffer("stdout", taskId);
-	}
-	function sendStderr(taskId) {
-		sendBuffer("stderr", taskId);
-	}
-	function sendBuffer(type, taskId) {
-		const buffers = type === "stdout" ? stdoutBuffer : stderrBuffer, buffer = buffers.get(taskId);
-		if (!buffer) return;
-		if (state().config.printConsoleTrace) buffer.forEach(([buffer, origin]) => {
-			sendLog(type, taskId, String(buffer), buffer.length, origin);
-		});
-		else {
-			const content = buffer.map((i) => String(i[0])).join("");
-			sendLog(type, taskId, content, buffer.length);
-		}
-		const timer = timers.get(taskId);
-		if (buffers.delete(taskId), type === "stderr") timer.stderrTime = 0;
-		else timer.stdoutTime = 0;
-	}
-	function sendLog(type, taskId, content, size, origin) {
-		const timer = timers.get(taskId), time = type === "stderr" ? timer.stderrTime : timer.stdoutTime;
-		state().rpc.onUserConsoleLog({
-			type,
-			content: content || "<empty line>",
-			taskId,
-			time: time || RealDate.now(),
-			size,
-			origin
-		});
-	}
-	const stdout = new Writable({ write(data, encoding, callback) {
-		const s = state(), id = s?.current?.id || s?.current?.suite?.id || s.current?.file.id || getTaskIdByStack(s.config.root);
-		let timer = timers.get(id);
-		if (timer) timer.stdoutTime = timer.stdoutTime || RealDate.now();
-		else timer = {
-			stdoutTime: RealDate.now(),
-			stderrTime: RealDate.now()
-		}, timers.set(id, timer);
-		let buffer = stdoutBuffer.get(id);
-		if (!buffer) buffer = [], stdoutBuffer.set(id, buffer);
-		if (state().config.printConsoleTrace) {
-			const limit = Error.stackTraceLimit;
-			Error.stackTraceLimit = limit + 6;
-			const trace = (/* @__PURE__ */ new Error("STACK_TRACE")).stack?.split("\n").slice(7).join("\n");
-			Error.stackTraceLimit = limit, buffer.push([data, trace]);
-		} else buffer.push([data, void 0]);
-		schedule(id), callback();
-	} }), stderr = new Writable({ write(data, encoding, callback) {
-		const s = state(), id = s?.current?.id || s?.current?.suite?.id || s.current?.file.id || getTaskIdByStack(s.config.root);
-		let timer = timers.get(id);
-		if (timer) timer.stderrTime = timer.stderrTime || RealDate.now();
-		else timer = {
-			stderrTime: RealDate.now(),
-			stdoutTime: RealDate.now()
-		}, timers.set(id, timer);
-		let buffer = stderrBuffer.get(id);
-		if (!buffer) buffer = [], stderrBuffer.set(id, buffer);
-		if (state().config.printConsoleTrace) {
-			const limit = Error.stackTraceLimit;
-			Error.stackTraceLimit = limit + 6;
-			const stack = (/* @__PURE__ */ new Error("STACK_TRACE")).stack?.split("\n");
-			if (Error.stackTraceLimit = limit, stack?.some((line) => line.includes("at Console.trace"))) buffer.push([data, void 0]);
-			else {
-				const trace = stack?.slice(7).join("\n");
-				Error.stackTraceLimit = limit, buffer.push([data, trace]);
-			}
-		} else buffer.push([data, void 0]);
-		schedule(id), callback();
-	} });
-	return new Console({
-		stdout,
-		stderr,
-		colorMode: c.isColorSupported,
-		groupIndentation: 2
-	});
-}
-
-export { UNKNOWN_TEST_ID, createCustomConsole };

package/dist/chunks/index.Bgo3tNWt.js

@@ -1,176 +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;
-  const rpcPromiseMap = /* @__PURE__ */ new Map();
-  let _promise;
-  let closed = false;
-  const rpc = new Proxy({}, {
-    get(_, method) {
-      if (method === "$functions")
-        return functions;
-      if (method === "$close")
-        return close;
-      if (method === "$rejectPendingCalls") {
-        return rejectPendingCalls;
-      }
-      if (method === "$closed")
-        return closed;
-      if (method === "then" && !eventNames.includes("then") && !("then" in functions))
-        return void 0;
-      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 = 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 });
-          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 = resolver ? resolver(method, functions[method]) : functions[method];
-      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 {
-            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) {
-        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[random() * 64 | 0];
-  return id;
-}
-
-export { createBirpc as c };