@apica-io/asm-playwright-runner 1.0.0-dev.1

package/asm-playwright-runner.iml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

package/dist/actions.js

@@ -0,0 +1,47 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.actionRegistry = void 0;
+function assertStringContains(source, expected) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const value = yield source();
+        if (!(value === null || value === void 0 ? void 0 : value.includes(expected))) {
+            throw new Error(`Expected "${expected}" in "${value}"`);
+        }
+    });
+}
+exports.actionRegistry = {
+    goto: (page, step) => __awaiter(void 0, void 0, void 0, function* () { return page.goto(step.url); }),
+    click: (page, step) => __awaiter(void 0, void 0, void 0, function* () { return page.click(step.selector); }),
+    type: (page, step) => __awaiter(void 0, void 0, void 0, function* () { return page.fill(step.selector, step.value); }),
+    screenshot: (page, step) => __awaiter(void 0, void 0, void 0, function* () { return page.screenshot({ path: step.path }); }),
+    reload: (page) => __awaiter(void 0, void 0, void 0, function* () { return page.reload(); }),
+    waitForSelector: (page, step) => __awaiter(void 0, void 0, void 0, function* () { return page.waitForSelector(step.selector); }),
+    hover: (page, step) => __awaiter(void 0, void 0, void 0, function* () { return page.hover(step.selector); }),
+    dblclick: (page, step) => __awaiter(void 0, void 0, void 0, function* () { return page.dblclick(step.selector); }),
+    check: (page, step) => __awaiter(void 0, void 0, void 0, function* () { return page.check(step.selector); }),
+    uncheck: (page, step) => __awaiter(void 0, void 0, void 0, function* () { return page.uncheck(step.selector); }),
+    selectOption: (page, step) => __awaiter(void 0, void 0, void 0, function* () { return page.selectOption(step.selector, step.value); }),
+    press: (page, step) => __awaiter(void 0, void 0, void 0, function* () { return page.press(step.selector, step.key); }),
+    waitForTimeout: (page, step) => __awaiter(void 0, void 0, void 0, function* () { return page.waitForTimeout(step.ms); }),
+    keyboardType: (page, step) => __awaiter(void 0, void 0, void 0, function* () { return page.keyboard.type(step.text); }),
+    keyboardPress: (page, step) => __awaiter(void 0, void 0, void 0, function* () { return page.keyboard.press(step.key); }),
+    assertText: (page, step) => __awaiter(void 0, void 0, void 0, function* () { return assertStringContains(() => page.textContent(step.selector), step.expected); }),
+    assertTitle: (page, step) => __awaiter(void 0, void 0, void 0, function* () { return assertStringContains(() => page.title(), step.expected); }),
+    uploadFile: (page, step) => __awaiter(void 0, void 0, void 0, function* () { return page.setInputFiles(step.selector, step.files); }),
+    waitForResponse: (page, step) => __awaiter(void 0, void 0, void 0, function* () { return page.waitForResponse(step.urlPattern); }),
+    assertVisible: (page, step) => __awaiter(void 0, void 0, void 0, function* () {
+        const isVisible = yield page.isVisible(step.selector);
+        if (!isVisible) {
+            throw new Error(`Expected element "${step.selector}" to be visible`);
+        }
+    })
+};

package/dist/cli/index.js

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const helper_1 = require("../lib/helper");
+const log4js = __importStar(require("log4js"));
+const fs_1 = __importDefault(require("fs"));
+const runner_1 = require("../runner");
+const cliLogConfig = {
+    appenders: {
+        out: {
+            type: "stdout",
+        },
+    },
+    categories: {
+        default: { appenders: ["out"], level: "INFO" },
+    },
+};
+var pack = (0, helper_1.getPackageInfo)();
+let version = pack.version || "version unknown";
+const program = new commander_1.Command();
+let data;
+program
+    .name("asm-playwright-runner")
+    .description("CLI wrapper for Playwright collections or scripts")
+    .version(version)
+    .argument("<collection>", "Flow JSON file or Playwright script")
+    .option("-b, --browser <browser>", "Browser type (chromium|firefox|webkit)", "chromium")
+    .option("-v, --verbose", "Print collection information on stdout", false)
+    .option("--chromiumPath <path>", "Custom Chromium/Chrome executable path")
+    .option("--headless", "Run browser headless (default true)", false)
+    .option("-r, --resultDir <dir>", "Result directory")
+    .option("-l, --logLevel <logLevel>", "Log level", "info")
+    .option("--extraHTTPHeaders <headers>", "Extra HTTP headers as JSON string")
+    .option("--timeout <timeout>", "Test timeout in ms")
+    .option("-rv, --returnResult", "Return the full structured test result object to the caller instead of only logging output", false)
+    .option("--sslClientCert <path>", "Client certificate (PEM)")
+    .option("--sslClientKey <path>", "Client certificate private key")
+    .option("--sslClientPassphrase <passphrase>", "Client certificate passphrase");
+program.version(version);
+program.parse(process.argv);
+let log_level = program.opts().logLevel || "info";
+log_level = log_level.toUpperCase();
+cliLogConfig.categories.default.level =
+    ["DEBUG", "TRACE", "ERROR", "FATAL"].includes(log_level) ? log_level : "INFO";
+cliLogConfig.categories.default.level = log_level;
+log4js.configure(cliLogConfig);
+var logger = log4js.getLogger(pack.name);
+logger.info("%s (%s) started", pack.name, version);
+// now construct runner
+const runner = new runner_1.PlaywrightRunner();
+(() => __awaiter(void 0, void 0, void 0, function* () {
+    const collection = program.args[0];
+    const options = program.opts();
+    if (!fs_1.default.existsSync(collection) || !fs_1.default.lstatSync(collection).isFile()) {
+        console.error("The specified collection file %s does not exist", collection);
+        process.exit(9);
+    }
+    yield runner.init(collection, options);
+    yield runner.run(collection, options);
+    yield runner.close();
+}))();

package/dist/lib/helper.js

@@ -0,0 +1,109 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectTraceFiles = exports.loadFlow = exports.traceZipToLines = exports.getPackageInfo = exports.readJsonFile = void 0;
+const fs_1 = __importDefault(require("fs"));
+const readline_1 = __importDefault(require("readline"));
+const unzipper_1 = __importDefault(require("unzipper"));
+const path_1 = __importDefault(require("path"));
+function readJsonFile(pathName) {
+    try {
+        let content = fs_1.default.readFileSync(pathName);
+        return JSON.parse(content.toString());
+    }
+    catch (error) {
+        return {};
+    }
+}
+exports.readJsonFile = readJsonFile;
+var packInfo;
+function getPackageInfo() {
+    if (packInfo === undefined) {
+        packInfo = readJsonFile(`${__dirname}/../../package.json`);
+    }
+    return packInfo;
+}
+exports.getPackageInfo = getPackageInfo;
+function traceZipToLines(tracePath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, e_1, _b, _c;
+        const directory = yield unzipper_1.default.Open.file(tracePath);
+        const traceEntry = directory.files.find(file => file.path.endsWith("test.trace"));
+        const events = [];
+        if (!traceEntry) {
+            return events;
+        }
+        const stream = traceEntry.stream();
+        const rl = readline_1.default.createInterface({
+            input: stream,
+            crlfDelay: Infinity,
+        });
+        try {
+            for (var _d = true, rl_1 = __asyncValues(rl), rl_1_1; rl_1_1 = yield rl_1.next(), _a = rl_1_1.done, !_a; _d = true) {
+                _c = rl_1_1.value;
+                _d = false;
+                const line = _c;
+                const text = line.toString().trim();
+                if (!text) {
+                    continue;
+                }
+                try {
+                    events.push(JSON.parse(text));
+                }
+                catch (err) {
+                    console.error("Invalid JSON:", text);
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = rl_1.return)) yield _b.call(rl_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return events;
+    });
+}
+exports.traceZipToLines = traceZipToLines;
+function loadFlow(filePath) {
+    const raw = fs_1.default.readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+}
+exports.loadFlow = loadFlow;
+function collectTraceFiles(resultDir) {
+    const traces = [];
+    const walk = (dir) => {
+        for (const entry of fs_1.default.readdirSync(dir)) {
+            const fullPath = path_1.default.join(dir, entry);
+            const stat = fs_1.default.statSync(fullPath);
+            if (stat.isDirectory()) {
+                walk(fullPath);
+            }
+            else if (entry === "trace.zip") {
+                traces.push(fullPath);
+            }
+        }
+    };
+    walk(resultDir);
+    return traces;
+}
+exports.collectTraceFiles = collectTraceFiles;

package/dist/lib/parser.js

@@ -0,0 +1,309 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareTraceModel = exports.prepareStackData = exports.setResources = exports.setActions = exports.setHookActions = exports.zipResources = exports.getFileData = exports.getJsonFileData = void 0;
+const unzipper_1 = __importDefault(require("unzipper"));
+const archiver_1 = __importDefault(require("archiver"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const runnerConfig_1 = require("../model/runnerConfig");
+function getJsonFileData(tracePath, fileName) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const directory = yield unzipper_1.default.Open.file(tracePath);
+        const file = directory.files.find(f => f.path.endsWith(fileName));
+        if (!file) {
+            return {};
+        }
+        const content = yield file.buffer();
+        return JSON.parse(content.toString("utf-8"));
+    });
+}
+exports.getJsonFileData = getJsonFileData;
+function getFileData(tracePath, fileName) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const directory = yield unzipper_1.default.Open.file(tracePath);
+        const traceFile = directory.files.find(f => f.path.endsWith(fileName));
+        if (!traceFile) {
+            return [];
+        }
+        const content = yield traceFile.buffer();
+        return content.toString('utf-8').split('\n').filter(Boolean);
+    });
+}
+exports.getFileData = getFileData;
+function extractResources(zipPath_1) {
+    return __awaiter(this, arguments, void 0, function* (zipPath, targetImages = []) {
+        const baseDir = path_1.default.dirname(zipPath);
+        const runName = path_1.default.basename(baseDir);
+        const resultDir = path_1.default.dirname(baseDir);
+        const parentDir = resultDir === "." ? runName : resultDir;
+        const appendRunName = resultDir === "." ? [] : [runName];
+        const screenshotsDir = path_1.default.join(parentDir, runnerConfig_1.ResultDir.SCREENSHOT, ...appendRunName);
+        const sourceDir = path_1.default.join(parentDir, runnerConfig_1.ResultDir.SOURCE, ...appendRunName);
+        // Create folders if not exists
+        [screenshotsDir, sourceDir].forEach(dir => {
+            if (!fs_1.default.existsSync(dir)) {
+                fs_1.default.mkdirSync(dir, { recursive: true });
+            }
+        });
+        const directory = yield unzipper_1.default.Open.file(zipPath);
+        // Copy target images
+        const imagePromises = targetImages.map(targetImage => {
+            const fileEntry = directory.files.find((file) => file.path === `resources/${targetImage}`);
+            if (!fileEntry) {
+                return Promise.resolve();
+            }
+            const outputPath = path_1.default.join(screenshotsDir, targetImage);
+            return new Promise((resolve, reject) => {
+                fileEntry
+                    .stream()
+                    .pipe(fs_1.default.createWriteStream(outputPath))
+                    .on('finish', () => {
+                    resolve(true);
+                })
+                    .on('error', reject);
+            });
+        });
+        // Copy all src@*.txt files
+        const sourcePromises = directory.files
+            .filter(file => file.path.startsWith('resources/') &&
+            /^src@.*\.txt$/.test(path_1.default.basename(file.path)))
+            .map(fileEntry => {
+            const fileName = path_1.default.basename(fileEntry.path);
+            const outputPath = path_1.default.join(sourceDir, fileName);
+            return new Promise((resolve, reject) => {
+                fileEntry
+                    .stream()
+                    .pipe(fs_1.default.createWriteStream(outputPath))
+                    .on('finish', () => {
+                    resolve(true);
+                })
+                    .on('error', reject);
+            });
+        });
+        yield Promise.all([...imagePromises, ...sourcePromises]);
+    });
+}
+function zipResources(outputZipPath, screenshotsDir, sourceDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve, reject) => {
+            const output = fs_1.default.createWriteStream(outputZipPath);
+            const archive = (0, archiver_1.default)("zip", { zlib: { level: 9 } });
+            output.on("close", resolve);
+            archive.on("error", reject);
+            archive.pipe(output);
+            if (fs_1.default.existsSync(screenshotsDir)) {
+                archive.directory(screenshotsDir, runnerConfig_1.ResultDir.SCREENSHOT);
+            }
+            if (fs_1.default.existsSync(sourceDir)) {
+                archive.directory(sourceDir, runnerConfig_1.ResultDir.SOURCE);
+            }
+            archive.finalize();
+        });
+    });
+}
+exports.zipResources = zipResources;
+function setHookActions(traceRawResult) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const hookModel = { actions: [], stdio: [] };
+        const hookActions = {};
+        for (const [index, row] of traceRawResult.entries()) {
+            const entry = JSON.parse(row);
+            if (entry.type === "context-options") {
+                Object.assign(hookModel, {
+                    origin: entry.origin,
+                    browserName: entry.browserName,
+                    playwrightVersion: entry.playwrightVersion,
+                    options: entry.options,
+                    platform: entry.platform,
+                    wallTime: entry.wallTime,
+                    startTime: entry.monotonicTime,
+                    sdkLanguage: entry.sdkLanguage,
+                    testIdAttributeName: entry.testIdAttributeName,
+                    contextId: entry.contextId,
+                    testTimeout: entry.testTimeout,
+                });
+                continue;
+            }
+            else if (entry.type === "stdout") {
+                (_a = hookModel === null || hookModel === void 0 ? void 0 : hookModel.stdio) === null || _a === void 0 ? void 0 : _a.push(entry);
+            }
+            else if (entry.type === "before") {
+                const action = {
+                    type: "action",
+                    callId: entry.callId,
+                    stepId: entry.stepId,
+                    parentId: entry.parentId,
+                    startTime: entry.startTime,
+                    class: entry.class,
+                    method: entry.method,
+                    title: entry.title,
+                    params: entry.params,
+                    stack: entry.stack,
+                    log: [],
+                };
+                hookActions[entry.callId] = action;
+                hookModel.actions.push(action);
+            }
+            else if (entry.type === "after" && hookActions[entry.callId]) {
+                Object.assign(hookActions[entry.callId], {
+                    endTime: entry.endTime,
+                    annotations: entry.annotations,
+                });
+            }
+            if (index === (traceRawResult.length - 1) && entry.type === "after") {
+                hookModel.endTime = entry.endTime;
+            }
+        }
+        return hookModel;
+    });
+}
+exports.setHookActions = setHookActions;
+function setActions(traceRawResult, traceModel, tracePath, stackData) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e;
+        let beforeFlag = false;
+        let action = null;
+        let targetImages = [];
+        for (const row of traceRawResult) {
+            const entry = JSON.parse(row);
+            if (entry.type === 'context-options') {
+                traceModel.origin = entry.origin;
+                traceModel.browserName = entry.browserName;
+                traceModel.playwrightVersion = entry.playwrightVersion;
+                traceModel.options = entry.options;
+                traceModel.platform = entry.platform;
+                traceModel.wallTime = entry.wallTime;
+                traceModel.startTime = entry.monotonicTime;
+                traceModel.sdkLanguage = entry.sdkLanguage;
+                traceModel.testIdAttributeName = entry.testIdAttributeName;
+                traceModel.contextId = entry.contextId;
+            }
+            else if (entry.type == "event" || entry.type == "console") {
+                (_a = traceModel.events) === null || _a === void 0 ? void 0 : _a.push(entry);
+            }
+            else if (entry.type == "screencast-frame") {
+                let page = (_b = traceModel.pages) === null || _b === void 0 ? void 0 : _b.find(p => p.pageId === entry.pageId);
+                if (!page) {
+                    page = {
+                        pageId: entry.pageId,
+                        screencastFrames: [],
+                    };
+                    (_c = traceModel.pages) === null || _c === void 0 ? void 0 : _c.push(page);
+                }
+                targetImages.push(entry.sha1);
+                page.screencastFrames.push(entry);
+            }
+            else {
+                if (entry.type == "before") {
+                    action = {
+                        callId: entry.callId,
+                        class: entry.class,
+                        method: entry.method,
+                        startTime: entry.startTime,
+                        type: "action",
+                        params: entry.params,
+                        pageId: entry.pageId,
+                        log: [],
+                        stack: stackData[entry.callId]
+                    };
+                    if (entry.class == "Frame") {
+                        action.beforeSnapshot = entry.beforeSnapshot;
+                    }
+                    beforeFlag = true;
+                }
+                if (beforeFlag && action != null && action.callId == entry.callId) {
+                    if (entry.type == "log") {
+                        (_d = action.log) === null || _d === void 0 ? void 0 : _d.push({
+                            time: entry.time,
+                            message: entry.message
+                        });
+                    }
+                    if (entry.type == "after") {
+                        beforeFlag = false;
+                        action.endTime = entry.endTime;
+                        action.result = entry.result;
+                        action.error = entry.error;
+                        action.afterSnapshot = entry.afterSnapshot;
+                        (_e = traceModel.actions) === null || _e === void 0 ? void 0 : _e.push(action);
+                    }
+                }
+            }
+        }
+        traceModel.endTime = action === null || action === void 0 ? void 0 : action.endTime;
+        yield extractResources(tracePath, targetImages);
+    });
+}
+exports.setActions = setActions;
+function setResources(resourceRawResult, traceModel) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        for (const row of resourceRawResult) {
+            const entry = JSON.parse(row);
+            (_a = traceModel.resources) === null || _a === void 0 ? void 0 : _a.push(entry.snapshot);
+        }
+    });
+}
+exports.setResources = setResources;
+function prepareStackData(stacksRawResult) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const preparedData = {};
+        const files = stacksRawResult.files || [];
+        const stacks = stacksRawResult.stacks || [];
+        for (const stack of stacks) {
+            const [callId, frames] = stack;
+            preparedData[`call@${callId}`] = frames.map(([fileIndex, line, column, fn]) => ({
+                file: files[fileIndex] || `source-file-${fileIndex}`,
+                fileIndex: `source-file-${fileIndex}`,
+                line,
+                column,
+                functionName: fn || ""
+            }));
+        }
+        return preparedData;
+    });
+}
+exports.prepareStackData = prepareStackData;
+function prepareTraceModel(tracePath, logLevel) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const traceRawResult = yield getFileData(tracePath, "trace.trace");
+        const resourceRawResult = yield getFileData(tracePath, "trace.network");
+        const stacksRawResult = yield getJsonFileData(tracePath, "trace.stacks");
+        const traceModel = {
+            actions: [],
+            events: [],
+            resources: [],
+            errors: [],
+            pages: []
+        };
+        if (logLevel == runnerConfig_1.LogLevel.DEBUG) {
+            fs_1.default.writeFileSync(path_1.default.join(path_1.default.dirname(tracePath), "trace-raw-data.json"), JSON.stringify(traceRawResult, null, 2), "utf-8");
+        }
+        const stackData = yield prepareStackData(stacksRawResult);
+        yield setActions(traceRawResult, traceModel, tracePath, stackData);
+        yield setResources(resourceRawResult, traceModel);
+        const testHookResult = yield getFileData(tracePath, "test.trace");
+        if (testHookResult && testHookResult.length > 0) {
+            if (logLevel == runnerConfig_1.LogLevel.DEBUG) {
+                //raw data to validate data from trace
+                fs_1.default.writeFileSync(path_1.default.join(path_1.default.dirname(tracePath), "test-trace-raw-data.json"), JSON.stringify(testHookResult, null, 2), "utf-8");
+            }
+            const hookModel = yield setHookActions(testHookResult);
+            return [hookModel, traceModel];
+        }
+        return [traceModel];
+    });
+}
+exports.prepareTraceModel = prepareTraceModel;

package/dist/loader.js

@@ -0,0 +1,5 @@
+import fs from "fs";
+export function loadFlow(filePath) {
+    const raw = fs.readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+}

package/dist/model/result.js

@@ -0,0 +1 @@
+export {};

package/dist/model/runnerConfig.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResultDir = exports.ScriptType = exports.LogLevel = exports.BrowserType = void 0;
+var BrowserType;
+(function (BrowserType) {
+    BrowserType["CHROMIUM"] = "chromium";
+    BrowserType["FIREFOX"] = "firefox";
+    BrowserType["WEBKIT"] = "webkit";
+})(BrowserType || (exports.BrowserType = BrowserType = {}));
+var LogLevel;
+(function (LogLevel) {
+    LogLevel["INFO"] = "info";
+    LogLevel["DEBUG"] = "debug";
+    LogLevel["ERROR"] = "error";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+var ScriptType;
+(function (ScriptType) {
+    ScriptType["JSON"] = "json";
+    ScriptType["PLAYWRIGHT"] = "playwright";
+    ScriptType["PLAYWRIGHT_TEST"] = "playwright/test";
+})(ScriptType || (exports.ScriptType = ScriptType = {}));
+var ResultDir;
+(function (ResultDir) {
+    ResultDir["BASE_DIR"] = "result";
+    ResultDir["SCREENSHOT"] = "screenshots";
+    ResultDir["SOURCE"] = "source";
+})(ResultDir || (exports.ResultDir = ResultDir = {}));

package/dist/model/traceModel.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });