@vitest/browser 0.25.2 → 0.25.4
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/client/__vitest__/assets/index.17258d7b.js +33 -0
- package/dist/client/__vitest__/index.html +1 -1
- package/dist/client/assets/index.5e00c68b.js +497 -0
- package/dist/client/index.html +1 -1
- package/package.json +7 -7
- package/dist/client/__vitest__/assets/index.0b7f73e8.js +0 -33
- package/dist/client/assets/index.891d93e6.js +0 -41
|
@@ -16,7 +16,7 @@
|
|
|
16
16
|
document.documentElement.classList.toggle('dark', true)
|
|
17
17
|
})()
|
|
18
18
|
</script>
|
|
19
|
-
<script type="module" crossorigin src="/__vitest__/assets/index.
|
|
19
|
+
<script type="module" crossorigin src="/__vitest__/assets/index.17258d7b.js"></script>
|
|
20
20
|
<link rel="stylesheet" href="/__vitest__/assets/index.9d14680d.css">
|
|
21
21
|
</head>
|
|
22
22
|
<body>
|
|
@@ -0,0 +1,497 @@
|
|
|
1
|
+
(function polyfill() {
|
|
2
|
+
const relList = document.createElement("link").relList;
|
|
3
|
+
if (relList && relList.supports && relList.supports("modulepreload")) {
|
|
4
|
+
return;
|
|
5
|
+
}
|
|
6
|
+
for (const link of document.querySelectorAll('link[rel="modulepreload"]')) {
|
|
7
|
+
processPreload(link);
|
|
8
|
+
}
|
|
9
|
+
new MutationObserver((mutations) => {
|
|
10
|
+
for (const mutation of mutations) {
|
|
11
|
+
if (mutation.type !== "childList") {
|
|
12
|
+
continue;
|
|
13
|
+
}
|
|
14
|
+
for (const node of mutation.addedNodes) {
|
|
15
|
+
if (node.tagName === "LINK" && node.rel === "modulepreload")
|
|
16
|
+
processPreload(node);
|
|
17
|
+
}
|
|
18
|
+
}
|
|
19
|
+
}).observe(document, { childList: true, subtree: true });
|
|
20
|
+
function getFetchOpts(script) {
|
|
21
|
+
const fetchOpts = {};
|
|
22
|
+
if (script.integrity)
|
|
23
|
+
fetchOpts.integrity = script.integrity;
|
|
24
|
+
if (script.referrerpolicy)
|
|
25
|
+
fetchOpts.referrerPolicy = script.referrerpolicy;
|
|
26
|
+
if (script.crossorigin === "use-credentials")
|
|
27
|
+
fetchOpts.credentials = "include";
|
|
28
|
+
else if (script.crossorigin === "anonymous")
|
|
29
|
+
fetchOpts.credentials = "omit";
|
|
30
|
+
else
|
|
31
|
+
fetchOpts.credentials = "same-origin";
|
|
32
|
+
return fetchOpts;
|
|
33
|
+
}
|
|
34
|
+
function processPreload(link) {
|
|
35
|
+
if (link.ep)
|
|
36
|
+
return;
|
|
37
|
+
link.ep = true;
|
|
38
|
+
const fetchOpts = getFetchOpts(link);
|
|
39
|
+
fetch(link.href, fetchOpts);
|
|
40
|
+
}
|
|
41
|
+
})();
|
|
42
|
+
const scriptRel = "modulepreload";
|
|
43
|
+
const assetsURL = function(dep) {
|
|
44
|
+
return "/" + dep;
|
|
45
|
+
};
|
|
46
|
+
const seen = {};
|
|
47
|
+
const __vitePreload = function preload(baseModule, deps, importerUrl) {
|
|
48
|
+
if (!deps || deps.length === 0) {
|
|
49
|
+
return baseModule();
|
|
50
|
+
}
|
|
51
|
+
const links = document.getElementsByTagName("link");
|
|
52
|
+
return Promise.all(deps.map((dep) => {
|
|
53
|
+
dep = assetsURL(dep);
|
|
54
|
+
if (dep in seen)
|
|
55
|
+
return;
|
|
56
|
+
seen[dep] = true;
|
|
57
|
+
const isCss = dep.endsWith(".css");
|
|
58
|
+
const cssSelector = isCss ? '[rel="stylesheet"]' : "";
|
|
59
|
+
const isBaseRelative = !!importerUrl;
|
|
60
|
+
if (isBaseRelative) {
|
|
61
|
+
for (let i = links.length - 1; i >= 0; i--) {
|
|
62
|
+
const link2 = links[i];
|
|
63
|
+
if (link2.href === dep && (!isCss || link2.rel === "stylesheet")) {
|
|
64
|
+
return;
|
|
65
|
+
}
|
|
66
|
+
}
|
|
67
|
+
} else if (document.querySelector(`link[href="${dep}"]${cssSelector}`)) {
|
|
68
|
+
return;
|
|
69
|
+
}
|
|
70
|
+
const link = document.createElement("link");
|
|
71
|
+
link.rel = isCss ? "stylesheet" : scriptRel;
|
|
72
|
+
if (!isCss) {
|
|
73
|
+
link.as = "script";
|
|
74
|
+
link.crossOrigin = "";
|
|
75
|
+
}
|
|
76
|
+
link.href = dep;
|
|
77
|
+
document.head.appendChild(link);
|
|
78
|
+
if (isCss) {
|
|
79
|
+
return new Promise((res, rej) => {
|
|
80
|
+
link.addEventListener("load", res);
|
|
81
|
+
link.addEventListener("error", () => rej(new Error(`Unable to preload CSS for ${dep}`)));
|
|
82
|
+
});
|
|
83
|
+
}
|
|
84
|
+
})).then(() => baseModule());
|
|
85
|
+
};
|
|
86
|
+
const DEFAULT_TIMEOUT = 6e4;
|
|
87
|
+
function createBirpc(functions, options) {
|
|
88
|
+
const {
|
|
89
|
+
post,
|
|
90
|
+
on,
|
|
91
|
+
eventNames = [],
|
|
92
|
+
serialize = (i) => i,
|
|
93
|
+
deserialize = (i) => i,
|
|
94
|
+
timeout = DEFAULT_TIMEOUT
|
|
95
|
+
} = options;
|
|
96
|
+
const rpcPromiseMap = /* @__PURE__ */ new Map();
|
|
97
|
+
const rpc = new Proxy({}, {
|
|
98
|
+
get(_, method) {
|
|
99
|
+
const sendEvent = (...args) => {
|
|
100
|
+
post(serialize({ m: method, a: args, t: "q" }));
|
|
101
|
+
};
|
|
102
|
+
if (eventNames.includes(method)) {
|
|
103
|
+
sendEvent.asEvent = sendEvent;
|
|
104
|
+
return sendEvent;
|
|
105
|
+
}
|
|
106
|
+
const sendCall = (...args) => {
|
|
107
|
+
return new Promise((resolve, reject) => {
|
|
108
|
+
const id = nanoid();
|
|
109
|
+
rpcPromiseMap.set(id, { resolve, reject });
|
|
110
|
+
post(serialize({ m: method, a: args, i: id, t: "q" }));
|
|
111
|
+
if (timeout >= 0) {
|
|
112
|
+
setTimeout(() => {
|
|
113
|
+
reject(new Error(`[birpc] timeout on calling "${method}"`));
|
|
114
|
+
rpcPromiseMap.delete(id);
|
|
115
|
+
}, timeout);
|
|
116
|
+
}
|
|
117
|
+
});
|
|
118
|
+
};
|
|
119
|
+
sendCall.asEvent = sendEvent;
|
|
120
|
+
return sendCall;
|
|
121
|
+
}
|
|
122
|
+
});
|
|
123
|
+
on(async (data, ...extra) => {
|
|
124
|
+
const msg = deserialize(data);
|
|
125
|
+
if (msg.t === "q") {
|
|
126
|
+
const { m: method, a: args } = msg;
|
|
127
|
+
let result, error;
|
|
128
|
+
try {
|
|
129
|
+
result = await functions[method].apply(rpc, args);
|
|
130
|
+
} catch (e) {
|
|
131
|
+
error = e;
|
|
132
|
+
}
|
|
133
|
+
if (msg.i)
|
|
134
|
+
post(serialize({ t: "s", i: msg.i, r: result, e: error }), ...extra);
|
|
135
|
+
} else {
|
|
136
|
+
const { i: ack, r: result, e: error } = msg;
|
|
137
|
+
const promise = rpcPromiseMap.get(ack);
|
|
138
|
+
if (error)
|
|
139
|
+
promise == null ? void 0 : promise.reject(error);
|
|
140
|
+
else
|
|
141
|
+
promise == null ? void 0 : promise.resolve(result);
|
|
142
|
+
rpcPromiseMap.delete(ack);
|
|
143
|
+
}
|
|
144
|
+
});
|
|
145
|
+
return rpc;
|
|
146
|
+
}
|
|
147
|
+
const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
|
|
148
|
+
function nanoid(size = 21) {
|
|
149
|
+
let id = "";
|
|
150
|
+
let i = size;
|
|
151
|
+
while (i--)
|
|
152
|
+
id += urlAlphabet[Math.random() * 64 | 0];
|
|
153
|
+
return id;
|
|
154
|
+
}
|
|
155
|
+
/*! (c) 2020 Andrea Giammarchi */
|
|
156
|
+
const { parse: $parse, stringify: $stringify } = JSON;
|
|
157
|
+
const { keys } = Object;
|
|
158
|
+
const Primitive = String;
|
|
159
|
+
const primitive = "string";
|
|
160
|
+
const ignore = {};
|
|
161
|
+
const object = "object";
|
|
162
|
+
const noop = (_, value) => value;
|
|
163
|
+
const primitives = (value) => value instanceof Primitive ? Primitive(value) : value;
|
|
164
|
+
const Primitives = (_, value) => typeof value === primitive ? new Primitive(value) : value;
|
|
165
|
+
const revive = (input, parsed, output, $) => {
|
|
166
|
+
const lazy = [];
|
|
167
|
+
for (let ke = keys(output), { length } = ke, y = 0; y < length; y++) {
|
|
168
|
+
const k = ke[y];
|
|
169
|
+
const value = output[k];
|
|
170
|
+
if (value instanceof Primitive) {
|
|
171
|
+
const tmp = input[value];
|
|
172
|
+
if (typeof tmp === object && !parsed.has(tmp)) {
|
|
173
|
+
parsed.add(tmp);
|
|
174
|
+
output[k] = ignore;
|
|
175
|
+
lazy.push({ k, a: [input, parsed, tmp, $] });
|
|
176
|
+
} else
|
|
177
|
+
output[k] = $.call(output, k, tmp);
|
|
178
|
+
} else if (output[k] !== ignore)
|
|
179
|
+
output[k] = $.call(output, k, value);
|
|
180
|
+
}
|
|
181
|
+
for (let { length } = lazy, i = 0; i < length; i++) {
|
|
182
|
+
const { k, a } = lazy[i];
|
|
183
|
+
output[k] = $.call(output, k, revive.apply(null, a));
|
|
184
|
+
}
|
|
185
|
+
return output;
|
|
186
|
+
};
|
|
187
|
+
const set = (known, input, value) => {
|
|
188
|
+
const index = Primitive(input.push(value) - 1);
|
|
189
|
+
known.set(value, index);
|
|
190
|
+
return index;
|
|
191
|
+
};
|
|
192
|
+
const parse = (text, reviver) => {
|
|
193
|
+
const input = $parse(text, Primitives).map(primitives);
|
|
194
|
+
const value = input[0];
|
|
195
|
+
const $ = reviver || noop;
|
|
196
|
+
const tmp = typeof value === object && value ? revive(input, /* @__PURE__ */ new Set(), value, $) : value;
|
|
197
|
+
return $.call({ "": tmp }, "", tmp);
|
|
198
|
+
};
|
|
199
|
+
const stringify = (value, replacer, space) => {
|
|
200
|
+
const $ = replacer && typeof replacer === object ? (k, v) => k === "" || -1 < replacer.indexOf(k) ? v : void 0 : replacer || noop;
|
|
201
|
+
const known = /* @__PURE__ */ new Map();
|
|
202
|
+
const input = [];
|
|
203
|
+
const output = [];
|
|
204
|
+
let i = +set(known, input, $.call({ "": value }, "", value));
|
|
205
|
+
let firstRun = !i;
|
|
206
|
+
while (i < input.length) {
|
|
207
|
+
firstRun = true;
|
|
208
|
+
output[i] = $stringify(input[i++], replace, space);
|
|
209
|
+
}
|
|
210
|
+
return "[" + output.join(",") + "]";
|
|
211
|
+
function replace(key, value2) {
|
|
212
|
+
if (firstRun) {
|
|
213
|
+
firstRun = !firstRun;
|
|
214
|
+
return value2;
|
|
215
|
+
}
|
|
216
|
+
const after = $.call(this, key, value2);
|
|
217
|
+
switch (typeof after) {
|
|
218
|
+
case object:
|
|
219
|
+
if (after === null)
|
|
220
|
+
return after;
|
|
221
|
+
case primitive:
|
|
222
|
+
return known.get(after) || set(known, input, after);
|
|
223
|
+
}
|
|
224
|
+
return after;
|
|
225
|
+
}
|
|
226
|
+
};
|
|
227
|
+
const isAggregateError = (err) => {
|
|
228
|
+
if (typeof AggregateError !== "undefined" && err instanceof AggregateError)
|
|
229
|
+
return true;
|
|
230
|
+
return err instanceof Error && "errors" in err;
|
|
231
|
+
};
|
|
232
|
+
class StateManager {
|
|
233
|
+
constructor() {
|
|
234
|
+
this.filesMap = /* @__PURE__ */ new Map();
|
|
235
|
+
this.pathsSet = /* @__PURE__ */ new Set();
|
|
236
|
+
this.collectingPromise = void 0;
|
|
237
|
+
this.idMap = /* @__PURE__ */ new Map();
|
|
238
|
+
this.taskFileMap = /* @__PURE__ */ new WeakMap();
|
|
239
|
+
this.errorsSet = /* @__PURE__ */ new Set();
|
|
240
|
+
}
|
|
241
|
+
catchError(err, type) {
|
|
242
|
+
if (isAggregateError(err))
|
|
243
|
+
return err.errors.forEach((error) => this.catchError(error, type));
|
|
244
|
+
err.type = type;
|
|
245
|
+
this.errorsSet.add(err);
|
|
246
|
+
}
|
|
247
|
+
clearErrors() {
|
|
248
|
+
this.errorsSet.clear();
|
|
249
|
+
}
|
|
250
|
+
getUnhandledErrors() {
|
|
251
|
+
return Array.from(this.errorsSet.values());
|
|
252
|
+
}
|
|
253
|
+
startCollectingPaths() {
|
|
254
|
+
let _resolve;
|
|
255
|
+
const promise = new Promise((resolve) => {
|
|
256
|
+
_resolve = resolve;
|
|
257
|
+
});
|
|
258
|
+
this.collectingPromise = { promise, resolve: _resolve };
|
|
259
|
+
}
|
|
260
|
+
finishCollectingPaths() {
|
|
261
|
+
var _a;
|
|
262
|
+
(_a = this.collectingPromise) == null ? void 0 : _a.resolve();
|
|
263
|
+
this.collectingPromise = void 0;
|
|
264
|
+
}
|
|
265
|
+
async getPaths() {
|
|
266
|
+
var _a;
|
|
267
|
+
await ((_a = this.collectingPromise) == null ? void 0 : _a.promise);
|
|
268
|
+
return Array.from(this.pathsSet);
|
|
269
|
+
}
|
|
270
|
+
getFiles(keys2) {
|
|
271
|
+
if (keys2)
|
|
272
|
+
return keys2.map((key) => this.filesMap.get(key)).filter(Boolean);
|
|
273
|
+
return Array.from(this.filesMap.values());
|
|
274
|
+
}
|
|
275
|
+
getFilepaths() {
|
|
276
|
+
return Array.from(this.filesMap.keys());
|
|
277
|
+
}
|
|
278
|
+
getFailedFilepaths() {
|
|
279
|
+
return this.getFiles().filter((i) => {
|
|
280
|
+
var _a;
|
|
281
|
+
return ((_a = i.result) == null ? void 0 : _a.state) === "fail";
|
|
282
|
+
}).map((i) => i.filepath);
|
|
283
|
+
}
|
|
284
|
+
collectPaths(paths = []) {
|
|
285
|
+
paths.forEach((path) => {
|
|
286
|
+
this.pathsSet.add(path);
|
|
287
|
+
});
|
|
288
|
+
}
|
|
289
|
+
collectFiles(files = []) {
|
|
290
|
+
files.forEach((file) => {
|
|
291
|
+
this.filesMap.set(file.filepath, file);
|
|
292
|
+
this.updateId(file);
|
|
293
|
+
});
|
|
294
|
+
}
|
|
295
|
+
clearFiles(paths = []) {
|
|
296
|
+
paths.forEach((path) => {
|
|
297
|
+
this.filesMap.delete(path);
|
|
298
|
+
});
|
|
299
|
+
}
|
|
300
|
+
updateId(task) {
|
|
301
|
+
if (this.idMap.get(task.id) === task)
|
|
302
|
+
return;
|
|
303
|
+
this.idMap.set(task.id, task);
|
|
304
|
+
if (task.type === "suite") {
|
|
305
|
+
task.tasks.forEach((task2) => {
|
|
306
|
+
this.updateId(task2);
|
|
307
|
+
});
|
|
308
|
+
}
|
|
309
|
+
}
|
|
310
|
+
updateTasks(packs) {
|
|
311
|
+
for (const [id, result] of packs) {
|
|
312
|
+
if (this.idMap.has(id))
|
|
313
|
+
this.idMap.get(id).result = result;
|
|
314
|
+
}
|
|
315
|
+
}
|
|
316
|
+
updateUserLog(log) {
|
|
317
|
+
const task = log.taskId && this.idMap.get(log.taskId);
|
|
318
|
+
if (task) {
|
|
319
|
+
if (!task.logs)
|
|
320
|
+
task.logs = [];
|
|
321
|
+
task.logs.push(log);
|
|
322
|
+
}
|
|
323
|
+
}
|
|
324
|
+
}
|
|
325
|
+
const RealDate = Date;
|
|
326
|
+
class MockDate extends RealDate {
|
|
327
|
+
constructor(y, m, d, h, M, s, ms) {
|
|
328
|
+
super();
|
|
329
|
+
let date;
|
|
330
|
+
switch (arguments.length) {
|
|
331
|
+
case 0:
|
|
332
|
+
date = new RealDate();
|
|
333
|
+
break;
|
|
334
|
+
case 1:
|
|
335
|
+
date = new RealDate(y);
|
|
336
|
+
break;
|
|
337
|
+
default:
|
|
338
|
+
d = typeof d === "undefined" ? 1 : d;
|
|
339
|
+
h = h || 0;
|
|
340
|
+
M = M || 0;
|
|
341
|
+
s = s || 0;
|
|
342
|
+
ms = ms || 0;
|
|
343
|
+
date = new RealDate(y, m, d, h, M, s, ms);
|
|
344
|
+
break;
|
|
345
|
+
}
|
|
346
|
+
return date;
|
|
347
|
+
}
|
|
348
|
+
}
|
|
349
|
+
MockDate.UTC = RealDate.UTC;
|
|
350
|
+
MockDate.now = function() {
|
|
351
|
+
return new MockDate().valueOf();
|
|
352
|
+
};
|
|
353
|
+
MockDate.parse = function(dateString) {
|
|
354
|
+
return RealDate.parse(dateString);
|
|
355
|
+
};
|
|
356
|
+
MockDate.toString = function() {
|
|
357
|
+
return RealDate.toString();
|
|
358
|
+
};
|
|
359
|
+
function createClient(url, options = {}) {
|
|
360
|
+
const {
|
|
361
|
+
handlers = {},
|
|
362
|
+
autoReconnect = true,
|
|
363
|
+
reconnectInterval = 2e3,
|
|
364
|
+
reconnectTries = 10,
|
|
365
|
+
reactive = (v) => v,
|
|
366
|
+
WebSocketConstructor = globalThis.WebSocket
|
|
367
|
+
} = options;
|
|
368
|
+
let tries = reconnectTries;
|
|
369
|
+
const ctx = reactive({
|
|
370
|
+
ws: new WebSocketConstructor(url),
|
|
371
|
+
state: new StateManager(),
|
|
372
|
+
waitForConnection,
|
|
373
|
+
reconnect
|
|
374
|
+
});
|
|
375
|
+
ctx.state.filesMap = reactive(ctx.state.filesMap);
|
|
376
|
+
ctx.state.idMap = reactive(ctx.state.idMap);
|
|
377
|
+
let onMessage;
|
|
378
|
+
const functions = {
|
|
379
|
+
onPathsCollected(paths) {
|
|
380
|
+
var _a;
|
|
381
|
+
ctx.state.collectPaths(paths);
|
|
382
|
+
(_a = handlers.onPathsCollected) == null ? void 0 : _a.call(handlers, paths);
|
|
383
|
+
},
|
|
384
|
+
onCollected(files) {
|
|
385
|
+
var _a;
|
|
386
|
+
ctx.state.collectFiles(files);
|
|
387
|
+
(_a = handlers.onCollected) == null ? void 0 : _a.call(handlers, files);
|
|
388
|
+
},
|
|
389
|
+
onTaskUpdate(packs) {
|
|
390
|
+
var _a;
|
|
391
|
+
ctx.state.updateTasks(packs);
|
|
392
|
+
(_a = handlers.onTaskUpdate) == null ? void 0 : _a.call(handlers, packs);
|
|
393
|
+
},
|
|
394
|
+
onUserConsoleLog(log) {
|
|
395
|
+
ctx.state.updateUserLog(log);
|
|
396
|
+
},
|
|
397
|
+
onFinished(files) {
|
|
398
|
+
var _a;
|
|
399
|
+
(_a = handlers.onFinished) == null ? void 0 : _a.call(handlers, files);
|
|
400
|
+
}
|
|
401
|
+
};
|
|
402
|
+
const birpcHandlers = {
|
|
403
|
+
post: (msg) => ctx.ws.send(msg),
|
|
404
|
+
on: (fn) => onMessage = fn,
|
|
405
|
+
serialize: stringify,
|
|
406
|
+
deserialize: parse
|
|
407
|
+
};
|
|
408
|
+
ctx.rpc = createBirpc(
|
|
409
|
+
functions,
|
|
410
|
+
birpcHandlers
|
|
411
|
+
);
|
|
412
|
+
let openPromise;
|
|
413
|
+
function reconnect(reset = false) {
|
|
414
|
+
if (reset)
|
|
415
|
+
tries = reconnectTries;
|
|
416
|
+
ctx.ws = new WebSocketConstructor(url);
|
|
417
|
+
registerWS();
|
|
418
|
+
}
|
|
419
|
+
function registerWS() {
|
|
420
|
+
openPromise = new Promise((resolve) => {
|
|
421
|
+
ctx.ws.addEventListener("open", () => {
|
|
422
|
+
tries = reconnectTries;
|
|
423
|
+
resolve();
|
|
424
|
+
});
|
|
425
|
+
});
|
|
426
|
+
ctx.ws.addEventListener("message", (v) => {
|
|
427
|
+
onMessage(v.data);
|
|
428
|
+
});
|
|
429
|
+
ctx.ws.addEventListener("close", () => {
|
|
430
|
+
tries -= 1;
|
|
431
|
+
if (autoReconnect && tries > 0)
|
|
432
|
+
setTimeout(reconnect, reconnectInterval);
|
|
433
|
+
});
|
|
434
|
+
}
|
|
435
|
+
registerWS();
|
|
436
|
+
function waitForConnection() {
|
|
437
|
+
return openPromise;
|
|
438
|
+
}
|
|
439
|
+
return ctx;
|
|
440
|
+
}
|
|
441
|
+
globalThis.process = { env: {}, argv: [], stdout: { write: () => {
|
|
442
|
+
} } };
|
|
443
|
+
globalThis.global = globalThis;
|
|
444
|
+
const PORT = location.port;
|
|
445
|
+
const HOST = [location.hostname, PORT].filter(Boolean).join(":");
|
|
446
|
+
const ENTRY_URL = `${location.protocol === "https:" ? "wss:" : "ws:"}//${HOST}/__vitest_api__`;
|
|
447
|
+
let config;
|
|
448
|
+
const browserHashMap = /* @__PURE__ */ new Map();
|
|
449
|
+
const client = createClient(ENTRY_URL, {
|
|
450
|
+
handlers: {
|
|
451
|
+
async onPathsCollected(paths) {
|
|
452
|
+
if (!paths)
|
|
453
|
+
return;
|
|
454
|
+
const now = `${new Date().getTime()}`;
|
|
455
|
+
paths.forEach((i) => {
|
|
456
|
+
browserHashMap.set(i, now);
|
|
457
|
+
});
|
|
458
|
+
await runTests(paths, config, client);
|
|
459
|
+
}
|
|
460
|
+
}
|
|
461
|
+
});
|
|
462
|
+
const ws = client.ws;
|
|
463
|
+
async function loadConfig() {
|
|
464
|
+
let retries = 5;
|
|
465
|
+
do {
|
|
466
|
+
try {
|
|
467
|
+
await new Promise((resolve) => setTimeout(resolve, 150));
|
|
468
|
+
config = await client.rpc.getConfig();
|
|
469
|
+
return;
|
|
470
|
+
} catch (_) {
|
|
471
|
+
}
|
|
472
|
+
} while (--retries > 0);
|
|
473
|
+
throw new Error("cannot load configuration after 5 retries");
|
|
474
|
+
}
|
|
475
|
+
ws.addEventListener("open", async () => {
|
|
476
|
+
await loadConfig();
|
|
477
|
+
globalThis.__vitest_worker__ = {
|
|
478
|
+
config,
|
|
479
|
+
browserHashMap,
|
|
480
|
+
rpc: client.rpc
|
|
481
|
+
};
|
|
482
|
+
globalThis.__vitest_mocker__ = {};
|
|
483
|
+
const paths = await client.rpc.getPaths();
|
|
484
|
+
const now = `${new Date().getTime()}`;
|
|
485
|
+
paths.forEach((i) => browserHashMap.set(i, now));
|
|
486
|
+
const iFrame = document.getElementById("vitest-ui");
|
|
487
|
+
iFrame.setAttribute("src", "/__vitest__/");
|
|
488
|
+
await runTests(paths, config, client);
|
|
489
|
+
});
|
|
490
|
+
async function runTests(paths, config2, client2) {
|
|
491
|
+
const name = "/__vitest_index__";
|
|
492
|
+
const { startTests, setupGlobalEnv } = await __vitePreload(() => import(name), true ? [] : void 0);
|
|
493
|
+
await setupGlobalEnv(config2);
|
|
494
|
+
await startTests(paths, config2);
|
|
495
|
+
await client2.rpc.onFinished();
|
|
496
|
+
await client2.rpc.onWatcherStart();
|
|
497
|
+
}
|
package/dist/client/index.html
CHANGED
package/package.json
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@vitest/browser",
|
|
3
3
|
"type": "module",
|
|
4
|
-
"version": "0.25.
|
|
4
|
+
"version": "0.25.4",
|
|
5
5
|
"description": "Browser running for Vitest",
|
|
6
6
|
"repository": {
|
|
7
7
|
"type": "git",
|
|
@@ -25,24 +25,24 @@
|
|
|
25
25
|
],
|
|
26
26
|
"dependencies": {
|
|
27
27
|
"local-pkg": "^0.4.2",
|
|
28
|
-
"mlly": "^0.
|
|
28
|
+
"mlly": "^1.0.0",
|
|
29
29
|
"modern-node-polyfills": "0.0.9",
|
|
30
30
|
"rollup-plugin-node-polyfills": "^0.2.1",
|
|
31
31
|
"sirv": "^2.0.2"
|
|
32
32
|
},
|
|
33
33
|
"devDependencies": {
|
|
34
34
|
"@types/ws": "^8.5.3",
|
|
35
|
-
"@vitest/ws-client": "0.25.
|
|
35
|
+
"@vitest/ws-client": "0.25.4",
|
|
36
36
|
"picocolors": "^1.0.0",
|
|
37
37
|
"rollup": "^2.79.1",
|
|
38
|
-
"vitest": "0.25.
|
|
38
|
+
"vitest": "0.25.4"
|
|
39
39
|
},
|
|
40
40
|
"scripts": {
|
|
41
41
|
"build": "rimraf dist && pnpm build:node && pnpm build:client && pnpm copy",
|
|
42
|
-
"build:client": "vite build",
|
|
42
|
+
"build:client": "vite build src/client",
|
|
43
43
|
"build:node": "rollup -c",
|
|
44
|
-
"dev:client": "vite build --watch",
|
|
45
|
-
"dev:node": "rollup -c --watch --watch.include
|
|
44
|
+
"dev:client": "vite build src/client --watch",
|
|
45
|
+
"dev:node": "rollup -c --watch --watch.include src/node/index.ts",
|
|
46
46
|
"dev": "rimraf dist && run-p dev:node dev:client",
|
|
47
47
|
"copy": "esno scripts/copy-ui-to-browser.ts"
|
|
48
48
|
}
|