playwright/utils/markdown.js

389 lines
11 KiB
JavaScript
Raw Normal View History

/**
* Copyright (c) Microsoft Corporation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
2020-12-29 04:38:00 +03:00
// @ts-check
/** @typedef {{
2021-01-12 23:14:27 +03:00
* type: 'text' | 'li' | 'code' | 'properties' | 'h0' | 'h1' | 'h2' | 'h3' | 'h4' | 'note',
2020-12-29 04:38:00 +03:00
* text?: string,
* codeLang?: string,
2021-01-12 23:14:27 +03:00
* noteType?: string,
2020-12-29 04:38:00 +03:00
* lines?: string[],
* liType?: 'default' | 'bullet' | 'ordinal',
* children?: MarkdownNode[]
* }} MarkdownNode */
function flattenWrappedLines(content) {
2021-01-09 02:00:14 +03:00
const inLines = content.replace(/\r\n/g, '\n').split('\n');
let inCodeBlock = false;
const outLines = [];
let outLineTokens = [];
for (const line of inLines) {
const trimmedLine = line.trim();
let singleLineExpression = line.startsWith('#');
let flushLastParagraph = !trimmedLine
|| trimmedLine.startsWith('1.')
|| trimmedLine.startsWith('<')
|| trimmedLine.startsWith('>')
|| trimmedLine.startsWith('|')
|| trimmedLine.startsWith('-')
|| trimmedLine.startsWith('*')
|| line.match(/\[[^\]]+\]:.*/)
|| singleLineExpression;
2021-01-12 23:14:27 +03:00
if (trimmedLine.startsWith('```') || trimmedLine.startsWith('---') || trimmedLine.startsWith(':::')) {
inCodeBlock = !inCodeBlock;
flushLastParagraph = true;
}
if (flushLastParagraph && outLineTokens.length) {
outLines.push(outLineTokens.join(' '));
outLineTokens = [];
}
if (inCodeBlock || singleLineExpression)
outLines.push(line);
else if (trimmedLine)
outLineTokens.push(outLineTokens.length ? line.trim() : line);
}
if (outLineTokens.length)
outLines.push(outLineTokens.join(' '));
return outLines;
}
2020-12-29 04:38:00 +03:00
/**
* @param {string[]} lines
*/
function buildTree(lines) {
2020-12-29 04:38:00 +03:00
/** @type {MarkdownNode} */
const root = {
2020-12-24 06:35:43 +03:00
type: 'h0',
2020-12-29 04:38:00 +03:00
text: '<root>',
children: []
};
2020-12-29 04:38:00 +03:00
/** @type {MarkdownNode[]} */
const headerStack = [root];
/** @type {{ indent: string, node: MarkdownNode }[]} */
let sectionStack = [];
/**
* @param {string} indent
* @param {MarkdownNode} node
*/
const appendNode = (indent, node) => {
while (sectionStack.length && sectionStack[0].indent.length >= indent.length)
sectionStack.shift();
const parentNode = sectionStack.length ? sectionStack[0].node :headerStack[0];
if (!parentNode.children)
parentNode.children = [];
parentNode.children.push(node);
if (node.type === 'li')
sectionStack.unshift({ indent, node });
};
for (let i = 0; i < lines.length; ++i) {
let line = lines[i];
// Headers form hierarchy.
const header = line.match(/^(#+)/);
if (header) {
const h = header[1].length;
2020-12-29 04:38:00 +03:00
const node = /** @type {MarkdownNode} */({ type: 'h' + h, text: line.substring(h + 1), children: [] });
while (true) {
const lastH = +headerStack[0].type.substring(1);
if (h <= lastH)
headerStack.shift();
else
break;
}
headerStack[0].children.push(node);
headerStack.unshift(node);
continue;
}
// Remaining items respect indent-based nesting.
const [, indent, content] = line.match('^([ ]*)(.*)');
if (content.startsWith('```')) {
/** @type {MarkdownNode} */
const node = {
type: 'code',
lines: [],
codeLang: content.substring(3)
};
line = lines[++i];
while (!line.trim().startsWith('```')) {
if (line && !line.startsWith(indent)) {
2021-01-09 02:00:14 +03:00
const from = Math.max(0, i - 5)
const to = Math.min(lines.length, from + 10);
const snippet = lines.slice(from, to);
throw new Error(`Bad code block: ${snippet.join('\n')}`);
}
if (line)
line = line.substring(indent.length);
node.lines.push(line);
line = lines[++i];
}
appendNode(indent, node);
continue;
}
2021-01-12 23:14:27 +03:00
if (content.startsWith(':::')) {
/** @type {MarkdownNode} */
const node = {
type: 'note',
noteType: content.substring(3)
2021-01-12 23:14:27 +03:00
};
line = lines[++i];
const tokens = [];
while (!line.trim().startsWith(':::')) {
if (!line.startsWith(indent)) {
const from = Math.max(0, i - 5)
const to = Math.min(lines.length, from + 10);
const snippet = lines.slice(from, to);
throw new Error(`Bad comment block: ${snippet.join('\n')}`);
}
tokens.push(line.substring(indent.length));
line = lines[++i];
}
node.text = tokens.join(' ');
appendNode(indent, node);
continue;
}
2021-01-02 02:17:27 +03:00
if (content.startsWith('---')) {
/** @type {MarkdownNode} */
const node = {
type: 'properties',
lines: [],
};
line = lines[++i];
while (!line.trim().startsWith('---')) {
if (!line.startsWith(indent))
throw new Error('Bad header block ' + line);
node.lines.push(line.substring(indent.length));
line = lines[++i];
}
appendNode(indent, node);
continue;
}
const liType = content.match(/^(-|1.|\*) /);
const node = /** @type {MarkdownNode} */({ type: 'text', text: content });
if (liType) {
2020-12-24 06:35:43 +03:00
node.type = 'li';
node.text = content.substring(liType[0].length);
if (content.startsWith('1.'))
2020-12-04 05:05:36 +03:00
node.liType = 'ordinal';
else if (content.startsWith('*'))
2020-12-04 05:05:36 +03:00
node.liType = 'bullet';
else
2020-12-04 05:05:36 +03:00
node.liType = 'default';
}
appendNode(indent, node);
}
return root.children;
}
2020-12-29 04:38:00 +03:00
/**
* @param {string} content
*/
function parse(content) {
return buildTree(flattenWrappedLines(content));
}
2020-12-29 04:38:00 +03:00
/**
* @param {MarkdownNode[]} nodes
2020-12-29 23:12:46 +03:00
* @param {number=} maxColumns
2020-12-29 04:38:00 +03:00
*/
2020-12-29 23:12:46 +03:00
function render(nodes, maxColumns) {
const result = [];
2020-12-04 05:05:36 +03:00
let lastNode;
for (let node of nodes) {
innerRenderMdNode('', node, lastNode, result, maxColumns);
2020-12-04 05:05:36 +03:00
lastNode = node;
}
return result.join('\n');
}
2020-12-29 04:38:00 +03:00
/**
* @param {string} indent
2020-12-29 04:38:00 +03:00
* @param {MarkdownNode} node
* @param {MarkdownNode} lastNode
2020-12-29 23:12:46 +03:00
* @param {number=} maxColumns
2020-12-29 04:38:00 +03:00
* @param {string[]} result
*/
function innerRenderMdNode(indent, node, lastNode, result, maxColumns) {
2020-12-04 05:05:36 +03:00
const newLine = () => {
if (result.length && result[result.length - 1] !== '')
2020-12-04 05:05:36 +03:00
result.push('');
};
2020-12-24 06:35:43 +03:00
if (node.type.startsWith('h')) {
newLine();
2020-12-29 04:38:00 +03:00
const depth = +node.type.substring(1);
2020-12-24 06:35:43 +03:00
result.push(`${'#'.repeat(depth)} ${node.text}`);
let lastNode = node;
for (const child of node.children || []) {
innerRenderMdNode('', child, lastNode, result, maxColumns);
2020-12-24 06:35:43 +03:00
lastNode = child;
}
2020-12-04 05:05:36 +03:00
}
2020-12-24 06:35:43 +03:00
if (node.type === 'text') {
const bothTables = node.text.startsWith('|') && lastNode && lastNode.type === 'text' && lastNode.text.startsWith('|');
const bothGen = node.text.startsWith('<!--') && lastNode && lastNode.type === 'text' && lastNode.text.startsWith('<!--');
2020-12-24 06:35:43 +03:00
const bothComments = node.text.startsWith('>') && lastNode && lastNode.type === 'text' && lastNode.text.startsWith('>');
const bothLinks = node.text.match(/\[[^\]]+\]:/) && lastNode && lastNode.type === 'text' && lastNode.text.match(/\[[^\]]+\]:/);
if (!bothTables && !bothGen && !bothComments && !bothLinks && lastNode && lastNode.text)
2020-12-04 05:05:36 +03:00
newLine();
for (const line of node.text.split('\n'))
result.push(wrapText(line, maxColumns, indent));
2021-01-02 02:17:27 +03:00
return;
2020-12-04 05:05:36 +03:00
}
2020-12-24 06:35:43 +03:00
if (node.type === 'code') {
2020-12-04 05:05:36 +03:00
newLine();
result.push(`${indent}\`\`\`${node.codeLang}`);
2020-12-24 06:35:43 +03:00
for (const line of node.lines)
result.push(indent + line);
result.push(`${indent}\`\`\``);
2020-12-04 05:05:36 +03:00
newLine();
2021-01-02 02:17:27 +03:00
return;
}
2021-01-12 23:14:27 +03:00
if (node.type === 'note') {
newLine();
result.push(`${indent}:::${node.noteType}`);
result.push(`${wrapText(node.text, maxColumns, indent)}`);
result.push(`${indent}:::`);
newLine();
return;
}
2021-01-02 02:17:27 +03:00
if (node.type === 'properties') {
result.push(`${indent}---`);
for (const line of node.lines)
result.push(indent + line);
result.push(`${indent}---`);
newLine();
return;
2020-12-04 05:05:36 +03:00
}
2020-12-24 06:35:43 +03:00
if (node.type === 'li') {
let char;
switch (node.liType) {
case 'bullet': char = '*'; break;
case 'default': char = '-'; break;
case 'ordinal': char = '1.'; break;
}
result.push(`${wrapText(node.text, maxColumns, `${indent}${char} `)}`);
const newIndent = indent + ' '.repeat(char.length + 1);
for (const child of node.children || []) {
innerRenderMdNode(newIndent, child, lastNode, result, maxColumns);
lastNode = child;
}
2020-12-04 05:05:36 +03:00
}
}
2020-12-29 23:12:46 +03:00
/**
* @param {string} text
*/
function tokenizeNoBreakLinks(text) {
2020-12-29 23:12:46 +03:00
const links = [];
// Don't wrap simple links with spaces.
text = text.replace(/\[[^\]]+\]/g, match => {
links.push(match);
return `[${links.length - 1}]`;
});
return text.split(' ').map(c => c.replace(/\[(\d+)\]/g, (_, p1) => links[+p1]));
}
/**
* @param {string} text
* @param {number=} maxColumns
* @param {string=} prefix
2020-12-29 23:12:46 +03:00
*/
function wrapText(text, maxColumns = 0, prefix = '') {
2020-12-29 23:12:46 +03:00
if (!maxColumns)
return prefix + text;
if (text.trim().startsWith('|'))
return prefix + text;
const indent = ' '.repeat(prefix.length);
2020-12-29 23:12:46 +03:00
const lines = [];
maxColumns -= indent.length;
const words = tokenizeNoBreakLinks(text);
2020-12-29 23:12:46 +03:00
let line = '';
for (const word of words) {
if (line.length && line.length + word.length < maxColumns) {
line += ' ' + word;
} else {
if (line)
lines.push(line);
line = (lines.length ? indent : prefix) + word;
2020-12-29 23:12:46 +03:00
}
}
if (line)
lines.push(line);
return lines.join('\n');
}
2020-12-29 04:38:00 +03:00
/**
* @param {MarkdownNode} node
*/
2020-12-24 06:35:43 +03:00
function clone(node) {
const copy = { ...node };
copy.children = copy.children ? copy.children.map(c => clone(c)) : undefined;
return copy;
}
2020-12-29 04:38:00 +03:00
/**
* @param {MarkdownNode[]} nodes
2021-01-02 02:17:27 +03:00
* @param {function(MarkdownNode, number): void} visitor
2020-12-29 04:38:00 +03:00
*/
function visitAll(nodes, visitor) {
for (const node of nodes)
visit(node, visitor);
2020-12-24 06:35:43 +03:00
}
/**
2020-12-29 04:38:00 +03:00
* @param {MarkdownNode} node
2021-01-02 02:17:27 +03:00
* @param {function(MarkdownNode, number): void} visitor
*/
2021-01-02 02:17:27 +03:00
function visit(node, visitor, depth = 0) {
visitor(node, depth);
2020-12-29 04:38:00 +03:00
for (const n of node.children || [])
2021-01-02 02:17:27 +03:00
visit(n, visitor, depth + 1);
}
/**
* @param {MarkdownNode[]} nodes
* @returns {string}
*/
function generateToc(nodes) {
const result = [];
visitAll(nodes, (node, depth) => {
if (node.type === 'h1' || node.type === 'h2') {
let link = node.text.toLowerCase();
link = link.replace(/[ ]+/g, '-');
link = link.replace(/[^\w-_]/g, '');
2021-01-02 02:17:27 +03:00
result.push(`${' '.repeat(depth * 2)}- [${node.text}](#${link})`);
}
});
return result.join('\n');
}
2021-01-02 02:17:27 +03:00
module.exports = { parse, render, clone, visitAll, visit, generateToc };