@tianshu-ai/tianshu 0.3.0

package/plugins/web-search/node_modules/vitest/dist/chunks/rpc.-pEldfrD.js

@@ -0,0 +1,83 @@
+import { getSafeTimers } from '@vitest/utils';
+import { c as createBirpc } from './index.B521nVV-.js';
+import { g as getWorkerState } from './utils.XdZDrNZV.js';
+
+const { get } = Reflect;
+function withSafeTimers(fn) {
+	const { setTimeout, clearTimeout, nextTick, setImmediate, clearImmediate } = getSafeTimers();
+	const currentSetTimeout = globalThis.setTimeout;
+	const currentClearTimeout = globalThis.clearTimeout;
+	const currentSetImmediate = globalThis.setImmediate;
+	const currentClearImmediate = globalThis.clearImmediate;
+	const currentNextTick = globalThis.process?.nextTick;
+	try {
+		globalThis.setTimeout = setTimeout;
+		globalThis.clearTimeout = clearTimeout;
+		globalThis.setImmediate = setImmediate;
+		globalThis.clearImmediate = clearImmediate;
+		if (globalThis.process) globalThis.process.nextTick = nextTick;
+		const result = fn();
+		return result;
+	} finally {
+		globalThis.setTimeout = currentSetTimeout;
+		globalThis.clearTimeout = currentClearTimeout;
+		globalThis.setImmediate = currentSetImmediate;
+		globalThis.clearImmediate = currentClearImmediate;
+		if (globalThis.process) nextTick(() => {
+			globalThis.process.nextTick = currentNextTick;
+		});
+	}
+}
+const promises = /* @__PURE__ */ new Set();
+async function rpcDone() {
+	if (!promises.size) return;
+	const awaitable = Array.from(promises);
+	return Promise.all(awaitable);
+}
+function createRuntimeRpc(options) {
+	let setCancel = (_reason) => {};
+	const onCancel = new Promise((resolve) => {
+		setCancel = resolve;
+	});
+	const rpc = createSafeRpc(createBirpc({ onCancel: setCancel }, {
+		eventNames: [
+			"onUserConsoleLog",
+			"onCollected",
+			"onCancel"
+		],
+		onTimeoutError(functionName, args) {
+			let message = `[vitest-worker]: Timeout calling "${functionName}"`;
+			if (functionName === "fetch" || functionName === "transform" || functionName === "resolveId") message += ` with "${JSON.stringify(args)}"`;
+			// JSON.stringify cannot serialize Error instances
+			if (functionName === "onUnhandledError") message += ` with "${args[0]?.message || args[0]}"`;
+			throw new Error(message);
+		},
+		...options
+	}));
+	return {
+		rpc,
+		onCancel
+	};
+}
+function createSafeRpc(rpc) {
+	return new Proxy(rpc, { get(target, p, handler) {
+		const sendCall = get(target, p, handler);
+		const safeSendCall = (...args) => withSafeTimers(async () => {
+			const result = sendCall(...args);
+			promises.add(result);
+			try {
+				return await result;
+			} finally {
+				promises.delete(result);
+			}
+		});
+		safeSendCall.asEvent = sendCall.asEvent;
+		return safeSendCall;
+	} });
+}
+function rpc() {
+	const { rpc } = getWorkerState();
+	return rpc;
+}
+
+export { rpcDone as a, createRuntimeRpc as c, rpc as r };

package/plugins/web-search/node_modules/vitest/dist/chunks/runBaseTests.9Ij9_de-.js

@@ -0,0 +1,129 @@
+import { performance } from 'node:perf_hooks';
+import { startTests, collectTests } from '@vitest/runner';
+import { a as resolveSnapshotEnvironment, s as setupChaiConfig, r as resolveTestRunner } from './index.CwejwG0H.js';
+import { c as setupCommonEnv, s as startCoverageInsideWorker, a as stopCoverageInsideWorker } from './setup-common.Dd054P77.js';
+import { a as globalExpect, v as vi } from './vi.bdSIJ99Y.js';
+import { c as closeInspector } from './inspector.C914Efll.js';
+import { createRequire } from 'node:module';
+import timers from 'node:timers';
+import timersPromises from 'node:timers/promises';
+import util from 'node:util';
+import { getSafeTimers } from '@vitest/utils';
+import { KNOWN_ASSET_TYPES } from 'vite-node/constants';
+import { installSourcemapsSupport } from 'vite-node/source-map';
+import { V as VitestIndex } from './index.CdQS2e2Q.js';
+import { g as getWorkerState, r as resetModules } from './utils.XdZDrNZV.js';
+import 'chai';
+import 'node:path';
+import '../path.js';
+import 'node:url';
+import './rpc.-pEldfrD.js';
+import './index.B521nVV-.js';
+import './coverage.DVF1vEu8.js';
+import '@vitest/snapshot';
+import '@vitest/expect';
+import '@vitest/runner/utils';
+import './_commonjsHelpers.BFTU3MAI.js';
+import '@vitest/utils/error';
+import '@vitest/spy';
+import '@vitest/utils/source-map';
+import './date.Bq6ZW5rf.js';
+import './benchmark.CYdenmiT.js';
+import 'expect-type';
+
+// this should only be used in Node
+let globalSetup = false;
+async function setupGlobalEnv(config, { environment }, executor) {
+	await setupCommonEnv(config);
+	Object.defineProperty(globalThis, "__vitest_index__", {
+		value: VitestIndex,
+		enumerable: false
+	});
+	const state = getWorkerState();
+	if (!state.config.snapshotOptions.snapshotEnvironment) state.config.snapshotOptions.snapshotEnvironment = await resolveSnapshotEnvironment(config, executor);
+	if (globalSetup) return;
+	globalSetup = true;
+	if (environment.transformMode === "web") {
+		const _require = createRequire(import.meta.url);
+		// always mock "required" `css` files, because we cannot process them
+		_require.extensions[".css"] = resolveCss;
+		_require.extensions[".scss"] = resolveCss;
+		_require.extensions[".sass"] = resolveCss;
+		_require.extensions[".less"] = resolveCss;
+		// since we are using Vite, we can assume how these will be resolved
+		KNOWN_ASSET_TYPES.forEach((type) => {
+			_require.extensions[`.${type}`] = resolveAsset;
+		});
+		process.env.SSR = "";
+	} else process.env.SSR = "1";
+	// @ts-expect-error not typed global for patched timers
+	globalThis.__vitest_required__ = {
+		util,
+		timers,
+		timersPromises
+	};
+	installSourcemapsSupport({ getSourceMap: (source) => state.moduleCache.getSourceMap(source) });
+	if (!config.disableConsoleIntercept) await setupConsoleLogSpy();
+}
+function resolveCss(mod) {
+	mod.exports = "";
+}
+function resolveAsset(mod, url) {
+	mod.exports = url;
+}
+async function setupConsoleLogSpy() {
+	const { createCustomConsole } = await import('./console.CtFJOzRO.js');
+	globalThis.console = createCustomConsole();
+}
+async function withEnv({ environment }, options, fn) {
+	// @ts-expect-error untyped global
+	globalThis.__vitest_environment__ = environment.name;
+	globalExpect.setState({ environment: environment.name });
+	const env = await environment.setup(globalThis, options);
+	try {
+		await fn();
+	} finally {
+		// Run possible setTimeouts, e.g. the onces used by ConsoleLogSpy
+		const { setTimeout } = getSafeTimers();
+		await new Promise((resolve) => setTimeout(resolve));
+		await env.teardown(globalThis);
+	}
+}
+
+// browser shouldn't call this!
+async function run(method, files, config, environment, executor) {
+	const workerState = getWorkerState();
+	const isIsolatedThreads = config.pool === "threads" && (config.poolOptions?.threads?.isolate ?? true);
+	const isIsolatedForks = config.pool === "forks" && (config.poolOptions?.forks?.isolate ?? true);
+	const isolate = isIsolatedThreads || isIsolatedForks;
+	await setupGlobalEnv(config, environment, executor);
+	await startCoverageInsideWorker(config.coverage, executor, { isolate });
+	if (config.chaiConfig) setupChaiConfig(config.chaiConfig);
+	const runner = await resolveTestRunner(config, executor);
+	workerState.onCancel.then((reason) => {
+		closeInspector(config);
+		runner.cancel?.(reason);
+	});
+	workerState.durations.prepare = performance.now() - workerState.durations.prepare;
+	workerState.durations.environment = performance.now();
+	await withEnv(environment, environment.options || config.environmentOptions || {}, async () => {
+		workerState.durations.environment = performance.now() - workerState.durations.environment;
+		for (const file of files) {
+			if (isolate) {
+				executor.mocker.reset();
+				resetModules(workerState.moduleCache, true);
+			}
+			workerState.filepath = file.filepath;
+			if (method === "run") await startTests([file], runner);
+			else await collectTests([file], runner);
+			// reset after tests, because user might call `vi.setConfig` in setupFile
+			vi.resetConfig();
+			// mocks should not affect different files
+			vi.restoreAllMocks();
+		}
+		await stopCoverageInsideWorker(config.coverage, executor, { isolate });
+	});
+	workerState.environmentTeardownRun = true;
+}
+
+export { run };

package/plugins/web-search/node_modules/vitest/dist/chunks/setup-common.Dd054P77.js

@@ -0,0 +1,60 @@
+import { r as resolveCoverageProviderModule } from './coverage.DVF1vEu8.js';
+import { addSerializer } from '@vitest/snapshot';
+import { setSafeTimers } from '@vitest/utils';
+
+async function startCoverageInsideWorker(options, loader, runtimeOptions) {
+	const coverageModule = await resolveCoverageProviderModule(options, loader);
+	if (coverageModule) return coverageModule.startCoverage?.(runtimeOptions);
+	return null;
+}
+async function takeCoverageInsideWorker(options, loader) {
+	const coverageModule = await resolveCoverageProviderModule(options, loader);
+	if (coverageModule) return coverageModule.takeCoverage?.({ moduleExecutionInfo: loader.moduleExecutionInfo });
+	return null;
+}
+async function stopCoverageInsideWorker(options, loader, runtimeOptions) {
+	const coverageModule = await resolveCoverageProviderModule(options, loader);
+	if (coverageModule) return coverageModule.stopCoverage?.(runtimeOptions);
+	return null;
+}
+
+let globalSetup = false;
+async function setupCommonEnv(config) {
+	setupDefines(config.defines);
+	setupEnv(config.env);
+	if (globalSetup) return;
+	globalSetup = true;
+	setSafeTimers();
+	if (config.globals) (await import('./globals.DEHgCU4V.js')).registerApiGlobally();
+}
+function setupDefines(defines) {
+	for (const key in defines) globalThis[key] = defines[key];
+}
+function setupEnv(env) {
+	if (typeof process === "undefined") return;
+	// same boolean-to-string assignment as VitestPlugin.configResolved
+	const { PROD, DEV,...restEnvs } = env;
+	process.env.PROD = PROD ? "1" : "";
+	process.env.DEV = DEV ? "1" : "";
+	for (const key in restEnvs) process.env[key] = env[key];
+}
+async function loadDiffConfig(config, executor) {
+	if (typeof config.diff === "object") return config.diff;
+	if (typeof config.diff !== "string") return;
+	const diffModule = await executor.executeId(config.diff);
+	if (diffModule && typeof diffModule.default === "object" && diffModule.default != null) return diffModule.default;
+	else throw new Error(`invalid diff config file ${config.diff}. Must have a default export with config object`);
+}
+async function loadSnapshotSerializers(config, executor) {
+	const files = config.snapshotSerializers;
+	const snapshotSerializers = await Promise.all(files.map(async (file) => {
+		const mo = await executor.executeId(file);
+		if (!mo || typeof mo.default !== "object" || mo.default === null) throw new Error(`invalid snapshot serializer file ${file}. Must export a default object`);
+		const config = mo.default;
+		if (typeof config.test !== "function" || typeof config.serialize !== "function" && typeof config.print !== "function") throw new TypeError(`invalid snapshot serializer in ${file}. Must have a 'test' method along with either a 'serialize' or 'print' method.`);
+		return config;
+	}));
+	snapshotSerializers.forEach((serializer) => addSerializer(serializer));
+}
+
+export { stopCoverageInsideWorker as a, loadSnapshotSerializers as b, setupCommonEnv as c, loadDiffConfig as l, startCoverageInsideWorker as s, takeCoverageInsideWorker as t };

package/plugins/web-search/node_modules/vitest/dist/chunks/suite.d.FvehnV49.d.ts

@@ -0,0 +1,10 @@
+import { Test } from '@vitest/runner';
+import { c as BenchmarkAPI, a as BenchFunction } from './benchmark.d.BwvBVTda.js';
+import { Options } from 'tinybench';
+import '@vitest/runner/utils';
+
+declare function getBenchOptions(key: Test): Options;
+declare function getBenchFn(key: Test): BenchFunction;
+declare const bench: BenchmarkAPI;
+
+export { getBenchOptions as a, bench as b, getBenchFn as g };