133 lines
4.9 KiB
Plaintext
133 lines
4.9 KiB
Plaintext
"use strict";
|
|
var __defProp = Object.defineProperty;
|
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
var __export = (target, all) => {
|
|
for (var name in all)
|
|
__defProp(target, name, { get: all[name], enumerable: true });
|
|
};
|
|
var __copyProps = (to, from, except, desc) => {
|
|
if (from && typeof from === "object" || typeof from === "function") {
|
|
for (let key of __getOwnPropNames(from))
|
|
if (!__hasOwnProp.call(to, key) && key !== except)
|
|
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
|
}
|
|
return to;
|
|
};
|
|
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
var traceLoader_exports = {};
|
|
__export(traceLoader_exports, {
|
|
TraceLoader: () => TraceLoader
|
|
});
|
|
module.exports = __toCommonJS(traceLoader_exports);
|
|
var import_traceUtils = require("./traceUtils");
|
|
var import_snapshotStorage = require("./snapshotStorage");
|
|
var import_traceModernizer = require("./traceModernizer");
|
|
class TraceLoader {
|
|
constructor() {
|
|
this.contextEntries = [];
|
|
this._resourceToContentType = /* @__PURE__ */ new Map();
|
|
}
|
|
async load(backend, traceFile, unzipProgress) {
|
|
this._backend = backend;
|
|
const prefix = traceFile?.match(/(.+)\.trace$/)?.[1];
|
|
const prefixes = [];
|
|
let hasSource = false;
|
|
for (const entryName of await this._backend.entryNames()) {
|
|
const match = entryName.match(/(.+)\.trace$/);
|
|
if (match && (!prefix || prefix === match[1]))
|
|
prefixes.push(match[1] || "");
|
|
if (entryName.includes("src@"))
|
|
hasSource = true;
|
|
}
|
|
if (!prefixes.length)
|
|
throw new Error("Cannot find .trace file");
|
|
this._snapshotStorage = new import_snapshotStorage.SnapshotStorage();
|
|
const total = prefixes.length * 3;
|
|
let done = 0;
|
|
for (const prefix2 of prefixes) {
|
|
const contextEntry = createEmptyContext();
|
|
contextEntry.hasSource = hasSource;
|
|
const modernizer = new import_traceModernizer.TraceModernizer(contextEntry, this._snapshotStorage);
|
|
const trace = await this._backend.readText(prefix2 + ".trace") || "";
|
|
modernizer.appendTrace(trace);
|
|
unzipProgress?.(++done, total);
|
|
const network = await this._backend.readText(prefix2 + ".network") || "";
|
|
modernizer.appendTrace(network);
|
|
unzipProgress?.(++done, total);
|
|
contextEntry.actions = modernizer.actions().sort((a1, a2) => a1.startTime - a2.startTime);
|
|
if (!backend.isLive()) {
|
|
for (const action of contextEntry.actions.slice().reverse()) {
|
|
if (!action.endTime && !action.error) {
|
|
for (const a of contextEntry.actions) {
|
|
if (a.parentId === action.callId && action.endTime < a.endTime)
|
|
action.endTime = a.endTime;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const stacks = await this._backend.readText(prefix2 + ".stacks");
|
|
if (stacks) {
|
|
const callMetadata = (0, import_traceUtils.parseClientSideCallMetadata)(JSON.parse(stacks));
|
|
for (const action of contextEntry.actions)
|
|
action.stack = action.stack || callMetadata.get(action.callId);
|
|
}
|
|
unzipProgress?.(++done, total);
|
|
for (const resource of contextEntry.resources) {
|
|
if (resource.request.postData?._sha1)
|
|
this._resourceToContentType.set(resource.request.postData._sha1, stripEncodingFromContentType(resource.request.postData.mimeType));
|
|
if (resource.response.content?._sha1)
|
|
this._resourceToContentType.set(resource.response.content._sha1, stripEncodingFromContentType(resource.response.content.mimeType));
|
|
}
|
|
this.contextEntries.push(contextEntry);
|
|
}
|
|
this._snapshotStorage.finalize();
|
|
}
|
|
async hasEntry(filename) {
|
|
return this._backend.hasEntry(filename);
|
|
}
|
|
async resourceForSha1(sha1) {
|
|
const blob = await this._backend.readBlob("resources/" + sha1);
|
|
const contentType = this._resourceToContentType.get(sha1);
|
|
if (!blob || contentType === void 0 || contentType === "x-unknown")
|
|
return blob;
|
|
return new Blob([blob], { type: contentType });
|
|
}
|
|
storage() {
|
|
return this._snapshotStorage;
|
|
}
|
|
}
|
|
function stripEncodingFromContentType(contentType) {
|
|
const charset = contentType.match(/^(.*);\s*charset=.*$/);
|
|
if (charset)
|
|
return charset[1];
|
|
return contentType;
|
|
}
|
|
function createEmptyContext() {
|
|
return {
|
|
origin: "testRunner",
|
|
startTime: Number.MAX_SAFE_INTEGER,
|
|
wallTime: Number.MAX_SAFE_INTEGER,
|
|
endTime: 0,
|
|
browserName: "",
|
|
options: {
|
|
deviceScaleFactor: 1,
|
|
isMobile: false,
|
|
viewport: { width: 1280, height: 800 }
|
|
},
|
|
pages: [],
|
|
resources: [],
|
|
actions: [],
|
|
events: [],
|
|
errors: [],
|
|
stdio: [],
|
|
hasSource: false,
|
|
contextId: ""
|
|
};
|
|
}
|
|
// Annotate the CommonJS export names for ESM import in node:
|
|
0 && (module.exports = {
|
|
TraceLoader
|
|
});
|