@kasperpeulen/vitest-plugin-nextjs 0.0.0-alpha.0 → 0.1.0-alpha.0

package/dist/node/v8.js

@@ -0,0 +1,160 @@
+import { Readable } from "node:stream";
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/mock/noop.mjs
+var noop_default = Object.assign(() => {}, { __unenv__: true });
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/v8/deserializer.mjs
+var Deserializer = class {
+	readHeader() {
+		return false;
+	}
+	readValue() {}
+	transferArrayBuffer(id, arrayBuffer) {}
+	getWireFormatVersion() {
+		return 0;
+	}
+	readUint32() {
+		return 0;
+	}
+	readUint64() {
+		return [0, 0];
+	}
+	readDouble() {
+		return 0;
+	}
+	readRawBytes(length) {
+		return Buffer.from("");
+	}
+};
+var DefaultDeserializer = class extends Deserializer {};
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/v8/serializer.mjs
+var Serializer = class {
+	writeHeader() {}
+	writeValue(val) {
+		return false;
+	}
+	releaseBuffer() {
+		return Buffer.from("");
+	}
+	transferArrayBuffer(id, arrayBuffer) {}
+	writeDouble(value) {}
+	writeUint32(value) {}
+	writeUint64(hi, lo) {}
+	writeRawBytes(buffer) {}
+};
+var DefaultSerializer = class extends Serializer {};
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/v8/profiler.mjs
+var GCProfiler = class {
+	start() {}
+	stop() {
+		return {
+			version: 1,
+			startTime: 0,
+			endTime: 0,
+			statistics: []
+		};
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/v8.mjs
+const getMockHeapSpaceStats = (name) => ({
+	space_name: name,
+	space_size: 0,
+	space_used_size: 0,
+	space_available_size: 0,
+	physical_space_size: 0
+});
+const cachedDataVersionTag = () => 0;
+const deserialize = noop_default;
+const getHeapCodeStatistics = () => ({
+	code_and_metadata_size: 0,
+	bytecode_and_metadata_size: 0,
+	external_script_source_size: 0,
+	cpu_profiler_metadata_size: 0
+});
+const getHeapSpaceStatistics = () => [
+	"read_only_space",
+	"new_space",
+	"old_space",
+	"code_space",
+	"map_space",
+	"large_object_space",
+	"code_large_object_space",
+	"new_large_object_space"
+].map((space) => getMockHeapSpaceStats(space));
+const getHeapStatistics = () => ({
+	total_heap_size: 0,
+	total_heap_size_executable: 0,
+	total_physical_size: 0,
+	total_available_size: 0,
+	used_heap_size: 0,
+	heap_size_limit: 0,
+	malloced_memory: 0,
+	peak_malloced_memory: 0,
+	does_zap_garbage: 0,
+	number_of_native_contexts: 0,
+	number_of_detached_contexts: 0,
+	total_global_handles_size: 0,
+	used_global_handles_size: 0,
+	external_memory: 0
+});
+const getHeapSnapshot = () => {
+	return Readable.from(`{
+    snapshot: {},
+    nodes: [],
+    edges: [],
+    trace_function_infos: [],
+    trace_tree: [],
+    samples: [],
+    locations: [],
+    strings: [],
+  }`);
+};
+const promiseHooks = {
+	onInit: () => noop_default,
+	onSettled: () => noop_default,
+	onBefore: () => noop_default,
+	onAfter: () => noop_default,
+	createHook: () => noop_default
+};
+const serialize = (value) => Buffer.from(value);
+const setFlagsFromString = noop_default;
+const setHeapSnapshotNearHeapLimit = noop_default;
+const startupSnapshot = {
+	addDeserializeCallback: noop_default,
+	addSerializeCallback: noop_default,
+	setDeserializeMainFunction: noop_default,
+	isBuildingSnapshot: () => false
+};
+const stopCoverage = noop_default;
+const takeCoverage = noop_default;
+const writeHeapSnapshot = () => "";
+function queryObjects(_ctor, options) {
+	if (options?.format === "count") return 0;
+	return [];
+}
+var v8_default = {
+	DefaultDeserializer,
+	Deserializer,
+	GCProfiler,
+	DefaultSerializer,
+	Serializer,
+	cachedDataVersionTag,
+	deserialize,
+	getHeapCodeStatistics,
+	getHeapSnapshot,
+	getHeapSpaceStatistics,
+	getHeapStatistics,
+	promiseHooks,
+	serialize,
+	setFlagsFromString,
+	setHeapSnapshotNearHeapLimit,
+	startupSnapshot,
+	stopCoverage,
+	takeCoverage,
+	writeHeapSnapshot,
+	queryObjects
+};
+//#endregion
+export { DefaultDeserializer, DefaultSerializer, Deserializer, GCProfiler, Serializer, cachedDataVersionTag, v8_default as default, deserialize, getHeapCodeStatistics, getHeapSnapshot, getHeapSpaceStatistics, getHeapStatistics, promiseHooks, queryObjects, serialize, setFlagsFromString, setHeapSnapshotNearHeapLimit, startupSnapshot, stopCoverage, takeCoverage, writeHeapSnapshot };

package/dist/node/vm.js

@@ -0,0 +1,88 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/_internal/utils.mjs
+/* @__NO_SIDE_EFFECTS__ */
+function createNotImplementedError(name) {
+	return /* @__PURE__ */ new Error(`[unenv] ${name} is not implemented yet!`);
+}
+/* @__NO_SIDE_EFFECTS__ */
+function notImplemented(name) {
+	const fn = () => {
+		throw /* @__PURE__ */ createNotImplementedError(name);
+	};
+	return Object.assign(fn, { __unenv__: true });
+}
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/vm/script.mjs
+var Script = class {
+	runInContext(contextifiedObject, options) {
+		throw /* @__PURE__ */ createNotImplementedError("Script.runInContext");
+	}
+	runInNewContext(contextObject, options) {
+		throw /* @__PURE__ */ createNotImplementedError("Script.runInNewContext");
+	}
+	runInThisContext(options) {
+		throw /* @__PURE__ */ createNotImplementedError("Script.runInThisContext");
+	}
+	createCachedData() {
+		throw /* @__PURE__ */ createNotImplementedError("Script.createCachedData");
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/vm/constants.mjs
+var constants_exports = /* @__PURE__ */ __exportAll({
+	DONT_CONTEXTIFY: () => DONT_CONTEXTIFY,
+	USE_MAIN_CONTEXT_DEFAULT_LOADER: () => USE_MAIN_CONTEXT_DEFAULT_LOADER
+});
+const USE_MAIN_CONTEXT_DEFAULT_LOADER = /* @__PURE__ */ Symbol("vm_dynamic_import_main_context_default");
+const DONT_CONTEXTIFY = /* @__PURE__ */ Symbol("vm_context_no_contextify");
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/vm.mjs
+const compileFunction = /* @__PURE__ */ notImplemented("vm.compileFunction");
+const _contextSymbol = /* @__PURE__ */ Symbol("uenv.vm.context");
+const createContext = function createContext() {
+	return Object.create(null, { [_contextSymbol]: { value: true } });
+};
+const createScript = function createScript() {
+	return new Script();
+};
+const isContext = (context) => {
+	return context && context[_contextSymbol] === true;
+};
+const measureMemory = () => Promise.resolve({
+	total: {
+		jsMemoryEstimate: 0,
+		jsMemoryRange: [1, 2]
+	},
+	WebAssembly: {
+		code: 0,
+		metadata: 0
+	}
+});
+const runInContext = /* @__PURE__ */ notImplemented("vm.runInContext");
+const runInNewContext = /* @__PURE__ */ notImplemented("vm.runInNewContext");
+const runInThisContext = /* @__PURE__ */ notImplemented("vm.runInThisContext");
+var vm_default = {
+	Script,
+	compileFunction,
+	constants: constants_exports,
+	createContext,
+	isContext,
+	measureMemory,
+	runInContext,
+	runInNewContext,
+	runInThisContext,
+	createScript
+};
+//#endregion
+export { Script, compileFunction, constants_exports as constants, createContext, createScript, vm_default as default, isContext, measureMemory, runInContext, runInNewContext, runInThisContext };

package/dist/node/wasi.js

@@ -0,0 +1,16 @@
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/_internal/utils.mjs
+/* @__NO_SIDE_EFFECTS__ */
+function notImplementedClass(name) {
+	return class {
+		__unenv__ = true;
+		constructor() {
+			throw new Error(`[unenv] ${name} is not implemented yet!`);
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/wasi.mjs
+const WASI = /* @__PURE__ */ notImplementedClass("wasi.WASI");
+var wasi_default = { WASI };
+//#endregion
+export { WASI, wasi_default as default };

package/dist/node/worker_threads.js

@@ -0,0 +1,123 @@
+import { EventEmitter } from "node:events";
+import { Readable } from "node:stream";
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/worker_threads/broadcast-channel.mjs
+var BroadcastChannel = class {
+	name = "";
+	onmessage = (message) => {};
+	onmessageerror = (message) => {};
+	close() {}
+	postMessage(message) {}
+	ref() {
+		return this;
+	}
+	unref() {
+		return this;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/worker_threads/message-port.mjs
+var MessagePort = class extends EventEmitter {
+	close() {}
+	postMessage(value, transferList) {}
+	ref() {}
+	unref() {}
+	start() {}
+	addEventListener(type, listener) {
+		this.on(type, listener);
+	}
+	removeEventListener(type, listener) {
+		this.off(type, listener);
+	}
+	dispatchEvent(event) {
+		return this.emit(event.type, event);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/worker_threads/message-channel.mjs
+var MessageChannel = class {
+	port1 = new MessagePort();
+	port2 = new MessagePort();
+};
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/worker_threads/worker.mjs
+var Worker = class extends EventEmitter {
+	stdin = null;
+	stdout = new Readable();
+	stderr = new Readable();
+	threadId = 0;
+	performance = { eventLoopUtilization: () => ({
+		idle: 0,
+		active: 0,
+		utilization: 0
+	}) };
+	postMessage(_value, _transferList) {}
+	postMessageToThread(_threadId, _value, _transferList, _timeout) {
+		return Promise.resolve();
+	}
+	ref() {}
+	unref() {}
+	terminate() {
+		return Promise.resolve(0);
+	}
+	getHeapSnapshot() {
+		return Promise.resolve(new Readable());
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/_internal/utils.mjs
+/* @__NO_SIDE_EFFECTS__ */
+function createNotImplementedError(name) {
+	return /* @__PURE__ */ new Error(`[unenv] ${name} is not implemented yet!`);
+}
+/* @__NO_SIDE_EFFECTS__ */
+function notImplemented(name) {
+	const fn = () => {
+		throw /* @__PURE__ */ createNotImplementedError(name);
+	};
+	return Object.assign(fn, { __unenv__: true });
+}
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/worker_threads.mjs
+const _environmentData = /* @__PURE__ */ new Map();
+const getEnvironmentData = function getEnvironmentData(key) {
+	return _environmentData.get(key);
+};
+const setEnvironmentData = function setEnvironmentData(key, value) {
+	_environmentData.set(key, value);
+};
+const isMainThread = true;
+const isMarkedAsUntransferable = () => false;
+const markAsUntransferable = function markAsUntransferable(value) {};
+const markAsUncloneable = () => {};
+const moveMessagePortToContext = () => new MessagePort();
+const parentPort = null;
+const receiveMessageOnPort = () => void 0;
+const SHARE_ENV = /* @__PURE__ */ Symbol.for("nodejs.worker_threads.SHARE_ENV");
+const resourceLimits = {};
+const threadId = 0;
+const workerData = null;
+const postMessageToThread = /* @__PURE__ */ notImplemented("worker_threads.postMessageToThread");
+const isInternalThread = false;
+var worker_threads_default = {
+	BroadcastChannel,
+	MessageChannel,
+	MessagePort,
+	Worker,
+	SHARE_ENV,
+	getEnvironmentData,
+	isMainThread: true,
+	isMarkedAsUntransferable,
+	markAsUntransferable,
+	markAsUncloneable,
+	moveMessagePortToContext,
+	parentPort: null,
+	receiveMessageOnPort,
+	resourceLimits,
+	setEnvironmentData,
+	postMessageToThread,
+	threadId: 0,
+	workerData: null,
+	isInternalThread: false
+};
+//#endregion
+export { BroadcastChannel, MessageChannel, MessagePort, SHARE_ENV, Worker, worker_threads_default as default, getEnvironmentData, isInternalThread, isMainThread, isMarkedAsUntransferable, markAsUncloneable, markAsUntransferable, moveMessagePortToContext, parentPort, postMessageToThread, receiveMessageOnPort, resourceLimits, setEnvironmentData, threadId, workerData };