|
1
|
"use strict"; |
|
2
|
var __create = Object.create; |
|
3
|
var __defProp = Object.defineProperty; |
|
4
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor; |
|
5
|
var __getOwnPropNames = Object.getOwnPropertyNames; |
|
6
|
var __getProtoOf = Object.getPrototypeOf; |
|
7
|
var __hasOwnProp = Object.prototype.hasOwnProperty; |
|
8
|
var __export = (target, all) => { |
|
9
|
for (var name in all) |
|
10
|
__defProp(target, name, { get: all[name], enumerable: true }); |
|
11
|
}; |
|
12
|
var __copyProps = (to, from, except, desc) => { |
|
13
|
if (from && typeof from === "object" || typeof from === "function") { |
|
14
|
for (let key of __getOwnPropNames(from)) |
|
15
|
if (!__hasOwnProp.call(to, key) && key !== except) |
|
16
|
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); |
|
17
|
} |
|
18
|
return to; |
|
19
|
}; |
|
20
|
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( |
|
21
|
// If the importer is in node compatibility mode or this is not an ESM |
|
22
|
// file that has been converted to a CommonJS file using a Babel- |
|
23
|
// compatible transform (i.e. "__esModule" has not been set), then set |
|
24
|
// "default" to the CommonJS "module.exports" for node compatibility. |
|
25
|
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, |
|
26
|
mod |
|
27
|
)); |
|
28
|
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); |
|
29
|
var md_exports = {}; |
|
30
|
__export(md_exports, { |
|
31
|
transformMDToTS: () => transformMDToTS |
|
32
|
}); |
|
33
|
module.exports = __toCommonJS(md_exports); |
|
34
|
var import_fs = __toESM(require("fs")); |
|
35
|
var import_path = __toESM(require("path")); |
|
36
|
var import_utilsBundle = require("../utilsBundle"); |
|
37
|
var import_babelBundle = require("./babelBundle"); |
|
38
|
function transformMDToTS(code, filename) { |
|
39
|
const parsed = parseSpec(code, filename); |
|
40
|
let fixtures = resolveFixtures(filename, parsed.props.find((prop) => prop[0] === "fixtures")?.[1]); |
|
41
|
const seed = parsed.props.find((prop) => prop[0] === "seed")?.[1]; |
|
42
|
if (seed) { |
|
43
|
const seedFile = import_path.default.resolve(import_path.default.dirname(filename), seed.text); |
|
44
|
const seedContents = import_fs.default.readFileSync(seedFile, "utf-8"); |
|
45
|
const parsedSeed = parseSpec(seedContents, seedFile); |
|
46
|
if (parsedSeed.tests.length !== 1) |
|
47
|
throw new Error(`while parsing ${seedFile}: seed file must contain exactly one test`); |
|
48
|
if (parsedSeed.tests[0].props.length) |
|
49
|
throw new Error(`while parsing ${seedFile}: seed test must not have properties`); |
|
50
|
for (const test of parsed.tests) |
|
51
|
test.lines = parsedSeed.tests[0].lines.concat(test.lines); |
|
52
|
const seedFixtures = resolveFixtures(seedFile, parsedSeed.props.find((prop) => prop[0] === "fixtures")?.[1]); |
|
53
|
if (seedFixtures && fixtures) |
|
54
|
throw new Error(`while parsing ${filename}: either seed or test can specify fixtures, but not both`); |
|
55
|
fixtures ??= seedFixtures; |
|
56
|
} |
|
57
|
const map = new import_babelBundle.genMapping.GenMapping({}); |
|
58
|
const lines = []; |
|
59
|
const addLine = (line) => { |
|
60
|
lines.push(line.text); |
|
61
|
if (line.source) { |
|
62
|
import_babelBundle.genMapping.addMapping(map, { |
|
63
|
generated: { line: lines.length, column: 0 }, |
|
64
|
source: line.source.filename, |
|
65
|
original: { line: line.source.line, column: line.source.column - 1 } |
|
66
|
}); |
|
67
|
} |
|
68
|
}; |
|
69
|
if (fixtures) |
|
70
|
addLine({ text: `import { test, expect } from ${escapeString(import_path.default.relative(import_path.default.dirname(filename), fixtures.text))};`, source: fixtures.source }); |
|
71
|
else |
|
72
|
addLine({ text: `import { test, expect } from '@playwright/test';` }); |
|
73
|
addLine({ text: `test.describe(${escapeString(parsed.describe.text)}, () => {`, source: parsed.describe.source }); |
|
74
|
for (const test of parsed.tests) { |
|
75
|
const tags = []; |
|
76
|
const annotations = []; |
|
77
|
for (const [key, value] of test.props) { |
|
78
|
if (key === "tag") { |
|
79
|
tags.push(...value.text.split(" ").map((s) => s.trim()).filter((s) => !!s)); |
|
80
|
} else if (key === "annotation") { |
|
81
|
if (!value.text.includes("=")) |
|
82
|
throw new Error(`while parsing ${filename}: annotation must be in format "type=description", found "${value}"`); |
|
83
|
const [type, description] = value.text.split("=").map((s) => s.trim()); |
|
84
|
annotations.push({ type, description }); |
|
85
|
} |
|
86
|
} |
|
87
|
let props = ""; |
|
88
|
if (tags.length || annotations.length) { |
|
89
|
props = "{ "; |
|
90
|
if (tags.length) |
|
91
|
props += `tag: [${tags.map((tag) => escapeString(tag)).join(", ")}], `; |
|
92
|
if (annotations.length) |
|
93
|
props += `annotation: [${annotations.map((a) => `{ type: ${escapeString(a.type)}, description: ${escapeString(a.description)} }`).join(", ")}], `; |
|
94
|
props += "}, "; |
|
95
|
} |
|
96
|
addLine({ text: ` test(${escapeString(test.title.text)}, ${props}async ({ page, agent }) => {`, source: test.title.source }); |
|
97
|
for (const line of test.lines) |
|
98
|
addLine({ text: " " + line.text, source: line.source }); |
|
99
|
addLine({ text: ` });`, source: test.title.source }); |
|
100
|
} |
|
101
|
addLine({ text: `});`, source: parsed.describe.source }); |
|
102
|
addLine({ text: `` }); |
|
103
|
const encodedMap = import_babelBundle.genMapping.toEncodedMap(map); |
|
104
|
const result = lines.join("\n"); |
|
105
|
return { code: result, map: encodedMap }; |
|
106
|
} |
|
107
|
function resolveFixtures(filename, prop) { |
|
108
|
if (!prop) |
|
109
|
return; |
|
110
|
return { text: import_path.default.resolve(import_path.default.dirname(filename), prop.text), source: prop.source }; |
|
111
|
} |
|
112
|
function escapeString(s) { |
|
113
|
return `'` + s.replace(/\n/g, " ").replace(/'/g, `\\'`) + `'`; |
|
114
|
} |
|
115
|
function parsingError(filename, node, message) { |
|
116
|
const position = node?.position?.start ? ` at ${node.position.start.line}:${node.position.start.column}` : ""; |
|
117
|
return new Error(`while parsing ${filename}${position}: ${message}`); |
|
118
|
} |
|
119
|
function asText(filename, node, errorMessage, skipChild) { |
|
120
|
let children = node.children.filter((child) => child !== skipChild); |
|
121
|
while (children.length === 1 && children[0].type === "paragraph") |
|
122
|
children = children[0].children; |
|
123
|
if (children.length !== 1 || children[0].type !== "text") |
|
124
|
throw parsingError(filename, node, errorMessage); |
|
125
|
return { text: children[0].value, source: node.position ? { filename, line: node.position.start.line, column: node.position.start.column } : void 0 }; |
|
126
|
} |
|
127
|
function parseSpec(content, filename) { |
|
128
|
const root = (0, import_utilsBundle.parseMarkdown)(content); |
|
129
|
const props = []; |
|
130
|
const children = [...root.children]; |
|
131
|
const describeNode = children[0]; |
|
132
|
children.shift(); |
|
133
|
if (describeNode?.type !== "heading" || describeNode.depth !== 2) |
|
134
|
throw parsingError(filename, describeNode, `describe title must be ##`); |
|
135
|
const describe = asText(filename, describeNode, `describe title must be ##`); |
|
136
|
if (children[0]?.type === "list") { |
|
137
|
parseProps(filename, children[0], props); |
|
138
|
children.shift(); |
|
139
|
} |
|
140
|
const tests = []; |
|
141
|
while (children.length) { |
|
142
|
let nextIndex = children.findIndex((n, i) => i > 0 && n.type === "heading" && n.depth === 3); |
|
143
|
if (nextIndex === -1) |
|
144
|
nextIndex = children.length; |
|
145
|
const testNodes = children.splice(0, nextIndex); |
|
146
|
tests.push(parseTest(filename, testNodes)); |
|
147
|
} |
|
148
|
return { describe, tests, props }; |
|
149
|
} |
|
150
|
function parseProp(filename, node, props) { |
|
151
|
const propText = asText(filename, node, `property must be a list item without children`); |
|
152
|
const match = propText.text.match(/^([^:]+):(.*)$/); |
|
153
|
if (!match) |
|
154
|
throw parsingError(filename, node, `property must be in format "key: value"`); |
|
155
|
props.push([match[1].trim(), { text: match[2].trim(), source: propText.source }]); |
|
156
|
} |
|
157
|
function parseProps(filename, node, props) { |
|
158
|
for (const prop of node.children || []) { |
|
159
|
if (prop.type !== "listItem") |
|
160
|
throw parsingError(filename, prop, `property must be a list item without children`); |
|
161
|
parseProp(filename, prop, props); |
|
162
|
} |
|
163
|
} |
|
164
|
function parseTest(filename, nodes) { |
|
165
|
const titleNode = nodes[0]; |
|
166
|
nodes.shift(); |
|
167
|
if (titleNode.type !== "heading" || titleNode.depth !== 3) |
|
168
|
throw parsingError(filename, titleNode, `test title must be ###`); |
|
169
|
const title = asText(filename, titleNode, `test title must be ###`); |
|
170
|
const props = []; |
|
171
|
let handlingProps = true; |
|
172
|
const lines = []; |
|
173
|
const visit = (node, indent) => { |
|
174
|
if (node.type === "list") { |
|
175
|
for (const child of node.children) |
|
176
|
visit(child, indent); |
|
177
|
return; |
|
178
|
} |
|
179
|
if (node.type === "listItem") { |
|
180
|
const listItem = node; |
|
181
|
const lastChild = listItem.children[listItem.children.length - 1]; |
|
182
|
if (lastChild?.type === "code") { |
|
183
|
handlingProps = false; |
|
184
|
const { text, source } = asText(filename, listItem, `code step must be a list item with a single code block`, lastChild); |
|
185
|
lines.push({ text: `${indent}await test.step(${escapeString(text)}, async () => {`, source }); |
|
186
|
for (const [index, code] of lastChild.value.split("\n").entries()) |
|
187
|
lines.push({ text: indent + " " + code, source: lastChild.position ? { filename, line: lastChild.position.start.line + 1 + index, column: lastChild.position.start.column } : void 0 }); |
|
188
|
lines.push({ text: `${indent}});`, source }); |
|
189
|
} else { |
|
190
|
const { text, source } = asText(filename, listItem, `step must contain a single instruction`, lastChild?.type === "list" ? lastChild : void 0); |
|
191
|
let isGroup = false; |
|
192
|
if (handlingProps && lastChild?.type !== "list" && ["tag:", "annotation:"].some((prefix) => text.startsWith(prefix))) { |
|
193
|
parseProp(filename, listItem, props); |
|
194
|
} else if (text.startsWith("group:")) { |
|
195
|
isGroup = true; |
|
196
|
lines.push({ text: `${indent}await test.step(${escapeString(text.substring("group:".length).trim())}, async () => {`, source }); |
|
197
|
} else if (text.startsWith("expect:")) { |
|
198
|
handlingProps = false; |
|
199
|
const assertion = text.substring("expect:".length).trim(); |
|
200
|
lines.push({ text: `${indent}await agent.expect(${escapeString(assertion)});`, source }); |
|
201
|
} else if (!text.startsWith("//")) { |
|
202
|
handlingProps = false; |
|
203
|
lines.push({ text: `${indent}await agent.perform(${escapeString(text)});`, source }); |
|
204
|
} |
|
205
|
if (lastChild?.type === "list") |
|
206
|
visit(lastChild, indent + (isGroup ? " " : "")); |
|
207
|
if (isGroup) |
|
208
|
lines.push({ text: `${indent}});`, source }); |
|
209
|
} |
|
210
|
} else { |
|
211
|
throw parsingError(filename, node, `test step must be a markdown list item`); |
|
212
|
} |
|
213
|
}; |
|
214
|
for (const node of nodes) |
|
215
|
visit(node, ""); |
|
216
|
return { title, lines, props }; |
|
217
|
} |
|
218
|
// Annotate the CommonJS export names for ESM import in node: |
|
219
|
0 && (module.exports = { |
|
220
|
transformMDToTS |
|
221
|
}); |
|
222
|
|