Files
eas-cli/scripts/src/markdown.ts
T
Dominik Sokal 04a8b08f59 [ENG-4579][scripts] convert to ESM (#1192)
* upgrade typescript to 4.7.4

* [scripts] add extensions to imports

* [scripts] configure as ESM

* [scripts] fix after converting to ESM

* [scripts] fix lint

* [scripts] require node >= 14.16

* [scripts] add node: protocol

* add scripts/build to .gitignore

* [scripts] add typecheck script

* add workflow for testing scripts

* address PR feedback
2022-07-04 11:50:57 +02:00

310 lines
7.6 KiB
TypeScript

// this is mostly copy-pasted from https://github.com/expo/expo/blob/master/tools/src/Markdown.ts
import { unescape } from 'lodash-es';
import marked from 'marked';
export enum TokenType {
HEADING = 'heading',
LIST = 'list',
LIST_ITEM = 'listItem',
PARAGRAPH = 'paragraph',
TEXT = 'text',
BLOCKQUOTE = 'blockquote',
SPACE = 'space',
CODE = 'code',
}
type SimpleToken<Type> = { type: Type; raw?: string };
export type TextToken<Type = TokenType.TEXT> = SimpleToken<Type> & { text: string };
export type HeadingToken = TextToken<TokenType.HEADING> & {
depth: number;
tokens: Token[];
};
export type ListToken = SimpleToken<TokenType.LIST> & {
depth: number;
items: ListItemToken[];
ordered?: boolean;
start?: string;
loose?: boolean;
};
export type ListItemToken = TextToken<TokenType.LIST_ITEM> & {
depth: number;
tokens: Token[];
task?: boolean;
checked?: boolean;
loose?: boolean;
};
export type ParagraphToken = TextToken<TokenType.PARAGRAPH>;
export type SpaceToken = SimpleToken<TokenType.SPACE>;
export type CodeToken = TextToken<TokenType.CODE> & {
lang: string;
};
export type BlockquoteToken = TextToken<TokenType.BLOCKQUOTE> & {
tokens: Token[];
};
export type Token =
| HeadingToken
| ListToken
| ListItemToken
| ParagraphToken
| TextToken
| SpaceToken
| CodeToken
| BlockquoteToken;
export interface Tokens extends Array<Token> {
links?: any;
}
export interface Renderer {
render(tokens: Token[]): string;
}
/**
* Receives markdown text and returns an array of tokens.
*/
export function lexify(text: string): Tokens {
const tokens = marked.lexer(text);
recursivelyFixTokens(tokens);
return tokens;
}
/**
* Receives an array of tokens and renders them to markdown.
*/
export function render(tokens: Tokens, renderer: Renderer = new MarkdownRenderer()): string {
// `marked` module is good enough in terms of lexifying, but its main purpose is to
// convert markdown to html, so we need to write our own renderer for changelogs.
return unescape(renderer.render(tokens).trim() + EOL);
}
/**
* Creates heading token with given text and depth.
*/
export function createHeadingToken(text: string, depth: number = 1): HeadingToken {
return {
type: TokenType.HEADING,
depth,
text,
tokens: [createTextToken(text)],
};
}
/**
* Returns a token from given text.
*/
export function createTextToken(text: string): TextToken {
return {
type: TokenType.TEXT,
text,
};
}
export function createListToken(depth: number = 1): ListToken {
return {
type: TokenType.LIST,
depth,
items: [],
};
}
export function createListItemToken(text: string, depth: number = 0): ListItemToken {
return {
type: TokenType.LIST_ITEM,
depth,
text,
tokens: [createTextToken(text)],
};
}
export function createSpaceToken(text: string): SpaceToken {
return {
type: TokenType.SPACE,
raw: text,
};
}
/**
* Type guard for tokens extending TextToken.
*/
export function isTextToken(token: Token): token is TextToken {
return token?.type === TokenType.TEXT;
}
/**
* Type guard for HeadingToken type.
*/
export function isHeadingToken(token: Token): token is HeadingToken {
return token?.type === TokenType.HEADING;
}
/**
* Type guard for ListToken type.
*/
export function isListToken(token: Token): token is ListToken {
return token?.type === TokenType.LIST;
}
/**
* Type guard for ListItemToken type.
*/
export function isListItemToken(token: Token): token is ListItemToken {
return token?.type === TokenType.LIST_ITEM;
}
/**
* Indents subsequent lines in given string.
*/
export function indentMultilineString(
str: string,
depth: number = 0,
indent: string = ' '
): string {
return str.replace(/\n/g, '\n' + indent.repeat(depth));
}
/**
* Fixes given tokens in place. We need to know depth of the list
*/
function recursivelyFixTokens(tokens: Token[], listDepth: number = 0): void {
for (const token of tokens) {
if (token.type === TokenType.LIST) {
token.depth = listDepth;
for (const item of token.items) {
item.type = TokenType.LIST_ITEM;
item.depth = listDepth;
recursivelyFixTokens(item.tokens, listDepth + 1);
}
}
}
}
const EOL = '\n';
export type RenderingContext = Partial<{
indent: number;
orderedList: boolean;
itemIndex: number;
}>;
export class MarkdownRenderer implements Renderer {
render(tokens: Token[]): string {
let output = '';
for (const token of tokens) {
output += this.renderToken(token, { indent: 0 });
}
return output;
}
/* helpers */
renderToken(token: Token, ctx: RenderingContext): string {
switch (token.type) {
case TokenType.HEADING:
return this.heading(token);
case TokenType.LIST:
return this.list(token, ctx);
case TokenType.LIST_ITEM:
return this.listItem(token, ctx);
case TokenType.PARAGRAPH:
return this.paragraph(token, ctx);
case TokenType.TEXT:
return this.text(token, ctx);
case TokenType.SPACE:
return this.space(token);
case TokenType.CODE:
return this.code(token, ctx);
case TokenType.BLOCKQUOTE:
return this.blockquote(token, ctx);
default:
// `marked` provides much more tokens, however we don't need to go so deep.
// So far we needed only tokens with above types.
throw new Error(`Cannot parse token: ${token}`);
}
}
indent(depth?: number, indentStr: string = ' '): string {
return depth ? indentStr.repeat(depth) : '';
}
/* tokens */
heading(token: HeadingToken): string {
return this.indent(token.depth, '#') + ' ' + token.text + EOL.repeat(2);
}
list(token: ListToken, ctx: { indent?: number }): string {
let output = '';
for (let i = 0; i < token.items.length; i++) {
output += this.listItem(token.items[i], {
...ctx,
orderedList: token.ordered,
itemIndex: i + 1,
});
}
return output;
}
listItem(token: ListItemToken, ctx: RenderingContext): string {
const indent = ctx.indent ?? 0;
const bullet = ctx.orderedList ? `${ctx.itemIndex ?? 1}.` : '-';
let output = this.indent(indent) + bullet + ' ';
if (token.tokens[0]) {
// `renderToken` result is indented by default (e.g. got TextToken), but when dealing with lists
// then list items indents are handled in above code instead
output += this.renderToken(token.tokens[0], ctx).trim() + EOL;
}
for (const child of token.tokens.slice(1)) {
output += this.renderToken(child, { ...ctx, indent: indent + 1 }).trimRight() + EOL;
}
return output.trimRight() + EOL;
}
paragraph(token: ParagraphToken, ctx: RenderingContext): string {
return this.indent(ctx.indent) + token.text + EOL;
}
text(token: TextToken, ctx: RenderingContext): string {
// TextToken may have children which we don't really need - they would render to `text` either way.
return this.indent(ctx.indent) + token.text;
}
space(_token: SpaceToken): string {
// Actually formatting of other tokens is good enough that we don't need to render additional newlines.
return EOL;
}
code(token: CodeToken, ctx: RenderingContext): string {
const lines = token.text.split(EOL);
const indentStr = this.indent(ctx?.indent);
lines.unshift('```' + token.lang ?? '');
lines.push('```');
return indentStr + lines.join(EOL + indentStr);
}
blockquote(token: BlockquoteToken, ctx: RenderingContext): string {
const indentStr = this.indent(ctx.indent);
return (
indentStr +
token.tokens
.map(child => '> ' + this.renderToken(child, { ...ctx, indent: 0 }).trimRight())
.join(EOL + indentStr)
);
}
}